JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitable; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper; import com.fasterxml.jackson.databind.jsonschema.SchemaAware; import com.fasterxml.jackson.databind.jsontype.TypeSerializer; import com.fasterxml.jackson.databind.ser.ContextualSerializer; import com.fasterxml.jackson.databind.ser.ResolvableSerializer; import com.fasterxml.jackson.databind.util.Converter; import java.io.IOException; import java.lang.reflect.Type; /** * Serializer implementation where given Java type is first converted * to an intermediate "delegate type" (using a configured * {@link Converter}, and then this delegate value is serialized by Jackson. *<p> * Note that although types may be related, they must not be same; trying * to do this will result in an exception. * * @since 2.1 */ @SuppressWarnings("serial") public class StdDelegatingSerializer extends StdSerializer<Object> implements ContextualSerializer, ResolvableSerializer, JsonFormatVisitable, SchemaAware { protected final Converter<Object,?> _converter; /** * Fully resolved delegate type, with generic information if any available. */ protected final JavaType _delegateType; /** * Underlying serializer for type <code>T<.code>. */ protected final JsonSerializer<Object> _delegateSerializer; /* /********************************************************** /* Life-cycle /********************************************************** */ @SuppressWarnings("unchecked") public StdDelegatingSerializer(Converter<?,?> converter) { super(Object.class); _converter = (Converter<Object,?>)converter; _delegateType = null; _delegateSerializer = null; } @SuppressWarnings("unchecked") public <T> StdDelegatingSerializer(Class<T> cls, Converter<T,?> converter) { super(cls, false); _converter = (Converter<Object,?>)converter; _delegateType = null; _delegateSerializer = null; } @

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>SuppressWarnings("unchecked") public StdDelegatingSerializer(Converter<Object,?> converter, JavaType delegateType, JsonSerializer<?> delegateSerializer) { super(delegateType); _converter = converter; _delegateType = delegateType; _delegateSerializer = (JsonSerializer<Object>) delegateSerializer; } /** * Method used for creating resolved contextual instances. Must be * overridden when sub-classing. */ protected StdDelegatingSerializer withDelegate(Converter<Object,?> converter, JavaType delegateType, JsonSerializer<?> delegateSerializer) { if (getClass() != StdDelegatingSerializer.class) { throw new IllegalStateException("Sub-class "+getClass().getName()+" must override 'withDelegate'"); } return new StdDelegatingSerializer(converter, delegateType, delegateSerializer); } /* /********************************************************** /* Contextualization /********************************************************** */ @Override public void resolve(SerializerProvider provider) throws JsonMappingException { if ((_delegateSerializer != null) return ((SchemaAware) _delegateSerializer).getSchema(provider, typeHint); } return super.getSchema(provider, typeHint);

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>handledType.isEnum()) { switch (shape) { case STRING: case NUMBER: case NUMBER_INT: // 12-Oct-2014, tatu: May need to introspect full annotations... but // for now, just do class ones BeanDescription desc = config.introspectClassAnnotations(_handledType); JsonSerializer<?> ser = EnumSerializer.construct(_handledType, provider.getConfig(), desc, format); return provider.handlePrimaryContextualization(ser, property); } } } } } ObjectIdWriter oiw = _objectIdWriter; String[] ignorals = null; Object newFilterId = null; // Then we may have an override for Object Id if (accessor != null) { ignorals = intr.findPropertiesToIgnore(accessor); ObjectIdInfo objectIdInfo = intr.findObjectIdInfo(accessor); if (objectIdInfo == null) { // no ObjectId override, but maybe ObjectIdRef? if (oiw != null) { objectIdInfo = intr.findObjectReferenceInfo(accessor, new ObjectIdInfo(NAME_FOR_OBJECT_REF, null, null, null)); oiw = _objectIdWriter.withAlwaysAsId(objectIdInfo.getAlwaysAsId()); } } else { /* Ugh: mostly copied from BeanSerializerBase: but can't easily * change it to be able to move to SerializerProvider (where it * really belongs) */ // 2.1: allow modifications by "id ref" annotations as well: objectIdInfo = intr.findObjectReferenceInfo(accessor, objectIdInfo); ObjectIdGenerator<?> gen; Class<?> implClass = objectIdInfo.getGeneratorType(); JavaType type = provider.constructType(implClass); JavaType idType = provider.getTypeFactory().findTypeParameters(type, ObjectIdGenerator.class)[0]; // Property-based generator is trickier if (implClass == ObjectIdGenerators.PropertyGenerator.class) { // most special one, needs extra work String propName = objectIdInfo.getPropertyName().getSimpleName(); BeanPropertyWriter idProp = null; for (int i = 0, len = _props.length ;; ++i) { if (i == len) { throw new IllegalArgumentException("Invalid Object Id

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> JsonGenerationException { /* note: almost verbatim copy of "serializeFields"; copied (instead of merged) * so that old method need not add check for existence of filter. */ final BeanPropertyWriter[] props; if (_filteredProps != null && provider.getActiveView() != null) { props = _filteredProps; } else { props = _props; } final PropertyFilter filter = findPropertyFilter(provider, _propertyFilterId, bean); // better also allow missing filter actually.. if (filter == null) { serializeFields(bean, jgen, provider); return; } int i = 0; try { for (final int len = props.length; i < len; ++i) { BeanPropertyWriter prop = props[i]; if (prop != null) { // can have nulls in filtered list filter.serializeAsField(bean, jgen, provider, prop); } } if (_anyGetterWriter != null) { _anyGetterWriter.getAndFilter(bean, jgen, provider, filter); } } catch (Exception e) { String name = (i == props.length) ? "[anySetter]" : props[i].getName(); wrapAndThrow(provider, e, bean, name); } catch (StackOverflowError e) { JsonMappingException mapE = new JsonMappingException("Infinite recursion (StackOverflowError)", e); String name = (i == props.length) ? "[anySetter]" : props[i].getName(); mapE.prependPath(new JsonMappingException.Reference(bean, name)); throw mapE; } } @Deprecated @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) throws JsonMappingException { ObjectNode o = createSchemaNode("object", true); // [JACKSON-813]: Add optional JSON Schema id attribute, if found // NOTE: not optimal, does NOT go through AnnotationIntrospector etc: JsonSerializableSchema ann = _handledType.getAnnotation(JsonSerializableSchema.class); if (ann != null) { String id = ann.id(); if (id != null && id.length() > 0) { o.put("id", id); } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind; import java.lang.reflect.Modifier; import com.fasterxml.jackson.core.type.ResolvedType; import com.fasterxml.jackson.databind.type.TypeFactory; /** * Base class for type token classes used both to contain information * and as keys for deserializers. *<p> * Instances can (only) be constructed by * <code>com.fasterxml.jackson.databind.type.TypeFactory</code>. *<p> * Since 2.2 this implements {@link java.lang.reflect.Type} to allow * it to be pushed through interfaces that only expose that type. */ public abstract class JavaType extends ResolvedType implements java.io.Serializable, // 2.1 java.lang.reflect.Type // 2.2 { private static final long serialVersionUID = 1; /** * This is the nominal type-erased Class that would be close to the * type represented (but not exactly type, due to type erasure: type * instance may have more information on this). * May be an interface or abstract class, so instantiation * may not be possible. */ protected final Class<?> _class; protected final int _hash; /** * Optional handler (codec) that can be attached to indicate * what to use for handling (serializing, deserializing) values of * this specific type. *<p> * Note: untyped (i.e. caller has to cast) because it is used for * different kinds of handlers, with unrelated types. */ protected final Object _valueHandler; /** * Optional handler that can be attached to indicate how to handle * additional type metadata associated with this type. *<p> * Note: untyped (i.e. caller has to cast) because it is used for * different kinds of handlers, with unrelated types. */ protected final Object _typeHandler; /** * Whether entities defined with this type should be handled using * static typing (as opposed to dynamic runtime type) or not. * * @since 2.2 */ protected final boolean _asStatic; /* /********************************************************** /* Life-cycle /********************************************************** */ /** * @param raw "

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>Raw" (type-erased) class for this type * @param additionalHash Additional hash code to use, in addition * to hash code of the class name */ protected JavaType(Class<?> raw, int additionalHash, Object valueHandler, Object typeHandler, boolean asStatic) { _class = raw; _hash = raw.getName().hashCode() + additionalHash; _valueHandler = valueHandler; _typeHandler = typeHandler; _asStatic = asStatic; } /** * "Copy method" that will construct a new instance that is identical to * this instance, except that it will have specified type handler assigned. * * @return Newly created type instance */ public abstract JavaType withTypeHandler(Object h); /** * "Copy method" that will construct a new instance that is identical to * this instance, except that its content type will have specified * type handler assigned. * * @return Newly created type instance */ public abstract JavaType withContentTypeHandler(Object h); /** * "Copy method" that will construct a new instance that is identical to * this instance, except that it will have specified value handler assigned. * * @return Newly created type instance */ public abstract JavaType withValueHandler(Object h); /** * "Copy method" that will construct a new instance that is identical to * this instance, except that it will have specified content value handler assigned. * * @return Newly created type instance */ public abstract JavaType withContentValueHandler(Object h); /** * Method that can be called to get a type instance that indicates * that values of the type should be handled using "static typing" for purposes * of serialization (as opposed to "dynamic" aka runtime typing): * meaning that no runtime information is needed for determining serializers to use. * The main use case is to allow forcing of specific root value serialization type, * and specifically in resolving serializers for contained types (element types * for arrays, Collections and Maps). * * @since 2.2 */ public abstract JavaType withStaticTyping(); /* /********************************************************** /* Type coercion fluent factory methods /********************************************************** */ /** * Method that can be called to do a "narrow

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>ing" conversions; that is, * to return a type with a raw class that is assignable to the raw * class of this type. If this is not possible, an * {@link IllegalArgumentException} is thrown. * If class is same as the current raw class, instance itself is * returned. */ public JavaType narrowBy(Class<?> subclass) { // First: if same raw class, just return this instance if (subclass == _class) { return this; } // Otherwise, ensure compatibility _assertSubclass(subclass, _class); JavaType result = _narrow(subclass); // TODO: these checks should NOT actually be needed; above should suffice: if (_valueHandler != result.<Object>getValueHandler()) { result = result.withValueHandler(_valueHandler); } if (_typeHandler != result.<Object>getTypeHandler()) { result = result.withTypeHandler(_typeHandler); } return result; } /** * More efficient version of {@link #narrowBy}, called by * internal framework in cases where compatibility checks * are to be skipped. */ public JavaType forcedNarrowBy(Class<?> subclass) { if (subclass == _class) { // can still optimize for simple case return this; } JavaType result = _narrow(subclass); // TODO: these checks should NOT actually be needed; above should suffice: if (_valueHandler != result.<Object>getValueHandler()) { result = result.withValueHandler(_valueHandler); } if (_typeHandler != result.<Object>getTypeHandler()) { result = result.withTypeHandler(_typeHandler); } return result; } /** * Method that can be called to do a "widening" conversions; that is, * to return a type with a raw class that could be assigned from this * type. * If such conversion is not possible, an * {@link IllegalArgumentException} is thrown. * If class is same as the current raw class, instance itself is * returned. */ public JavaType widenBy(Class<?> superclass) { // First: if same raw class, just return this instance if (superclass == _class) { return this; } // Otherwise, ensure compatibility _assertSubclass(_class, superclass); return

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> _widen(superclass); } protected abstract JavaType _narrow(Class<?> subclass); /** *<p> * Default implementation is just to call {@link #_narrow}, since * underlying type construction is usually identical */ protected JavaType _widen(Class<?> superclass) { return _narrow(superclass); } public abstract JavaType narrowContentsBy(Class<?> contentClass); public abstract JavaType widenContentsBy(Class<?> contentClass); /* /********************************************************** /* Implementation of ResolvedType API /********************************************************** */ @Override public final Class<?> getRawClass() { return _class; } /** * Method that can be used to check whether this type has * specified Class as its type erasure. Put another way, returns * true if instantiation of this Type is given (type-erased) Class. */ @Override public final boolean hasRawClass(Class<?> clz) { return _class == clz; } @Override public boolean isAbstract() { return Modifier.isAbstract(_class.getModifiers()); } /** * Convenience method for checking whether underlying Java type * is a concrete class or not: abstract classes and interfaces * are not. */ @Override public boolean isConcrete() { int mod = _class.getModifiers(); if ((mod & (Modifier.INTERFACE | Modifier.ABSTRACT)) == 0) { return true; } /* 19-Feb-2010, tatus: Holy mackarel; primitive types * have 'abstract' flag set... */ return _class.isPrimitive(); } @Override public boolean isThrowable() { return Throwable.class.isAssignableFrom(_class); } @Override public boolean isArrayType() { return false; } @Override public final boolean isEnumType() { return _class.isEnum(); } @Override public final boolean isInterface() { return _class.isInterface(); } @Override public final boolean isPrimitive() { return _class.isPrimitive(); } @Override public final boolean isFinal() { return Modifier.isFinal(_class.getModifiers()); } /** * @return True if type represented is a container type; this includes * array, Map and Collection types. */

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> String toCanonical(); /** * Method for accessing signature that contains generic * type information, in form compatible with JVM 1.5 * as per JLS. It is a superset of {@link #getErasedSignature}, * in that generic information can be automatically removed * if necessary (just remove outermost * angle brackets along with content inside) */ public String getGenericSignature() { StringBuilder sb = new StringBuilder(40); getGenericSignature(sb); return sb.toString(); } /** * * @param sb StringBuilder to append signature to * * @return StringBuilder that was passed in; returned to allow * call chaining */ public abstract StringBuilder getGenericSignature(StringBuilder sb); /** * Method for accessing signature without generic * type information, in form compatible with all versions * of JVM, and specifically used for type descriptions * when generating byte code. */ public String getErasedSignature() { StringBuilder sb = new StringBuilder(40); getErasedSignature(sb); return sb.toString(); } /** * Method for accessing signature without generic * type information, in form compatible with all versions * of JVM, and specifically used for type descriptions * when generating byte code. * * @param sb StringBuilder to append signature to * * @return StringBuilder that was passed in; returned to allow * call chaining */ public abstract StringBuilder getErasedSignature(StringBuilder sb); /* /********************************************************** /* Helper methods /********************************************************** */ protected void _assertSubclass(Class<?> subclass, Class<?> superClass) { if (!_class.isAssignableFrom(subclass)) { throw new IllegalArgumentException("Class "+subclass.getName()+" is not assignable to "+_class.getName()); } } /* /********************************************************** /* Standard methods; let's make them abstract to force override /********************************************************** */ @Override public abstract String toString(); @Override public abstract boolean equals(Object o); @Override public final int hashCode() { return _hash; } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> * we want to check if a type is a bean after some of "standard" JDK * types, but before the rest. * As a result, "mixed" delegation used, and calls are NOT done using * regular {@link SerializerFactory} interface but rather via * direct calls to {@link BasicSerializerFactory}. *<p> * Finally, since all caching is handled by the serializer provider * (not factory) and there is no configurability, this * factory is stateless. * This means that a global singleton instance can be used. */ public class BeanSerializerFactory extends BasicSerializerFactory implements java.io.Serializable // since 2.1 { private static final long serialVersionUID = 1; /** * Like {@link BasicSerializerFactory}, this factory is stateless, and * thus a single shared global (== singleton) instance can be used * without thread-safety issues. */ public final static BeanSerializerFactory instance = new BeanSerializerFactory(null); /* /********************************************************** /* Life-cycle: creation, configuration /********************************************************** */ /** * Constructor for creating instances with specified configuration. */ protected BeanSerializerFactory(SerializerFactoryConfig config) { super(config); } /** * Method used by module registration functionality, to attach additional * serializer providers into this serializer factory. This is typically * handled by constructing a new instance with additional serializers, * to ensure thread-safe access. */ @Override public SerializerFactory withConfig(SerializerFactoryConfig config) { if (_factoryConfig == config) { return this; } /* 22-Nov-2010, tatu: Handling of subtypes is tricky if we do immutable-with-copy-ctor; * and we pretty much have to here either choose between losing subtype instance * when registering additional serializers, or losing serializers. * Instead, let's actually just throw an error if this method is called when subtype * has not properly overridden this method; this to indicate problem as soon as possible. */ if (getClass() != BeanSerializerFactory.class) { throw new IllegalStateException("Subtype of BeanSerializerFactory ("+getClass().getName() +") has not properly overridden method 'withAdditionalSerializers': can not instantiate subtype with " +"additional

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> serializer definitions"); } return new BeanSerializerFactory(config); } @Override protected Iterable<Serializers> customSerializers() { return _factoryConfig.serializers(); } /* /********************************************************** /* SerializerFactory impl /********************************************************** */ /** * Main serializer constructor method. We will have to be careful * with respect to ordering of various method calls: essentially * we want to reliably figure out which classes are standard types, * and which are beans. The problem is that some bean Classes may * implement standard interfaces (say, {@link java.lang.Iterable}. *<p> * Note: sub-classes may choose to complete replace implementation, * if they want to alter priority of serializer lookups. */ @Override @SuppressWarnings("unchecked") public JsonSerializer<Object> createSerializer(SerializerProvider prov, JavaType origType) throws JsonMappingException { // Very first thing, let's check if there is explicit serializer annotation: final SerializationConfig config = prov.getConfig(); BeanDescription beanDesc = config.introspect(origType); JsonSerializer<?> ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); if (ser != null) { return (JsonSerializer<Object>) ser; } boolean staticTyping; // Next: we may have annotations that further define types to use... JavaType type = modifyTypeByAnnotation(config, beanDesc.getClassInfo(), origType); if (type == origType) { // no changes, won't force static typing staticTyping = false; } else { // changes; assume static typing; plus, need to re-introspect if class differs } final SerializationConfig config = prov.getConfig(); // Container types differ from non-container types // (note: called method checks for module-provided serializers) if (type.isContainerType()) { if (!staticTyping) { staticTyping = usesStaticTyping(config, beanDesc, null); // [Issue#23]: Need to figure out how to force passed parameterization // to stick... /* if (property == null) { JavaType t = origType.getContentType(); if (t != null && !t.hasRawClass(Object.class)) { staticTyping = true; } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> */ } // 03-Aug-2012, tatu: As per [Issue#40], may require POJO serializer... ser = buildContainerSerializer(prov, type, beanDesc, staticTyping); // Will return right away, since called method does post-processing: if (ser != null) { return ser; } } else { // Modules may provide serializers of POJO types: for (Serializers serializers : customSerializers()) { ser = serializers.findSerializer(config, type, beanDesc); if (ser != null) { break; } } } // Otherwise, we will check "primary types"; both marker types that // indicate specific handling (JsonSerializable), or main types that have // precedence over container types if (ser == null) { ser = findSerializerByLookup(type, config, beanDesc, staticTyping); if (ser == null) { ser = findSerializerByPrimaryType(prov, type, beanDesc, staticTyping); if (ser == null) { // And this is where this class comes in: if type is not a // known "primary JDK type", perhaps it's a bean? We can still // get a null, if we can't find a single suitable bean property. ser = findBeanSerializer(prov, type, beanDesc); // Finally: maybe we can still deal with it as an implementation of some basic JDK interface? if (ser == null) { ser = findSerializerByAddonType(config, type, beanDesc, staticTyping); // 18-Sep-2014, tatu: Actually, as per [jackson-databind#539], need to get // 'unknown' serializer assigned earlier, here, so that it gets properly // post-processed if (ser == null) { ser = prov.getUnknownTypeSerializer(beanDesc.getBeanClass()); } } } } } if (ser != null) { // [Issue#120]: Allow post-processing if (_factoryConfig.hasSerializerModifiers()) { for (BeanSerializerModifier mod : _factoryConfig.serializerModifiers()) { ser = mod.modifySerializer(config, beanDesc, ser); } } } return ser;

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> one is needed; null if not. */ public TypeSerializer findPropertyContentTypeSerializer(JavaType containerType, SerializationConfig config, AnnotatedMember accessor) throws JsonMappingException { JavaType contentType = containerType.getContentType(); AnnotationIntrospector ai = config.getAnnotationIntrospector(); TypeResolverBuilder<?> b = ai.findPropertyContentTypeResolver(config, accessor, containerType); // Defaulting: if no annotations on member, check value class if (b == null) { return createTypeSerializer(config, contentType); } Collection<NamedType> subtypes = config.getSubtypeResolver().collectAndResolveSubtypes(accessor, config, ai, contentType); return b.buildTypeSerializer(config, contentType, subtypes); } /* /********************************************************** /* Overridable non-public factory methods /********************************************************** */ /** * Method called to construct serializer for serializing specified bean type. * * @since 2.1 */ @SuppressWarnings("unchecked") protected JsonSerializer<Object> constructBeanSerializer(SerializerProvider prov, BeanDescription beanDesc) throws JsonMappingException { // 13-Oct-2010, tatu: quick sanity check: never try to create bean serializer for plain Object // 05-Jul-2012, tatu: ... but we should be able to just return "unknown type" serializer, right? if (beanDesc.getBeanClass() == Object.class) { return prov.getUnknownTypeSerializer(Object.class); // throw new IllegalArgumentException("Can not create bean serializer for Object.class"); } final SerializationConfig config = prov.getConfig(); BeanSerializerBuilder builder = constructBeanSerializerBuilder(beanDesc); builder.setConfig(config); // First: any detectable (auto-detect, annotations) properties to serialize? List<BeanPropertyWriter> props = findBeanProperties(prov, beanDesc, builder); if (props == null) { props = new ArrayList<BeanPropertyWriter>(); } // [databind#638]: Allow injection of "virtual" properties: prov.getAnnotationIntrospector().findAndAddVirtualProperties(config, beanDesc.getClassInfo(), props); // [JACKSON-440] Need to allow modification bean properties to

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>, PropertyMetadata.STD_OPTIONAL); builder.setAnyGetter(new AnyGetterWriter(anyProp, anyGetter, anySer)); } // Next: need to gather view information, if any: processViews(config, builder); // Finally: let interested parties mess with the result bit more... if (_factoryConfig.hasSerializerModifiers()) { for (BeanSerializerModifier mod : _factoryConfig.serializerModifiers()) { builder = mod.updateBuilder(config, beanDesc, builder); } } JsonSerializer<Object> ser = (JsonSerializer<Object>) builder.build(); if (ser == null) { // If we get this far, there were no properties found, so no regular BeanSerializer // would be constructed. But, couple of exceptions. // First: if there are known annotations, just create 'empty bean' serializer if (beanDesc.hasKnownClassAnnotations()) { return builder.createDummy(); } } return ser; } protected ObjectIdWriter constructObjectIdHandler(SerializerProvider prov, BeanDescription beanDesc, List<BeanPropertyWriter> props) throws JsonMappingException { ObjectIdInfo objectIdInfo = beanDesc.getObjectIdInfo(); if (objectIdInfo == null) { return null; } ObjectIdGenerator<?> gen; Class<?> implClass = objectIdInfo.getGeneratorType(); // Just one special case: Property-based generator is trickier if (implClass == ObjectIdGenerators.PropertyGenerator.class) { // most special one, needs extra work String propName = objectIdInfo.getPropertyName().getSimpleName(); BeanPropertyWriter idProp = null; for (int i = 0, len = props.size() ;; ++i) { if (i == len) { throw new IllegalArgumentException("Invalid Object Id definition for "+beanDesc.getBeanClass().getName() +": can not find property with name '"+propName+"'"); } BeanPropertyWriter prop = props.get(i); if (propName.equals(prop.getName())) { idProp = prop; /* Let's force it to be the first property to output * (although it may still get rearranged etc) */ if (i > 0) { props.remove(i); props.add(0, idProp); }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> break; } } JavaType idType = idProp.getType(); gen = new PropertyBasedObjectIdGenerator(objectIdInfo, idProp); // one more thing: must ensure that ObjectIdWriter does not actually write the value: return ObjectIdWriter.construct(idType, (PropertyName) null, gen, objectIdInfo.getAlwaysAsId()); } // other types are simpler JavaType type = prov.constructType(implClass); // Could require type to be passed explicitly, but we should be able to find it too: JavaType idType = prov.getTypeFactory().findTypeParameters(type, ObjectIdGenerator.class)[0]; gen = prov.objectIdGeneratorInstance(beanDesc.getClassInfo(), objectIdInfo); return ObjectIdWriter.construct(idType, objectIdInfo.getPropertyName(), gen, objectIdInfo.getAlwaysAsId()); } /** * Method called to construct a filtered writer, for given view * definitions. Default implementation constructs filter that checks * active view type to views property is to be included in. */ protected BeanPropertyWriter constructFilteredBeanWriter(BeanPropertyWriter writer, Class<?>[] inViews) { return FilteredBeanPropertyWriter.constructViewBased(writer, inViews); } protected PropertyBuilder constructPropertyBuilder(SerializationConfig config, BeanDescription beanDesc) { return new PropertyBuilder(config, beanDesc); } protected BeanSerializerBuilder constructBeanSerializerBuilder(BeanDescription beanDesc) { return new BeanSerializerBuilder(beanDesc); } /* /********************************************************** /* Overridable non-public introspection methods /********************************************************** */ /** * Helper method used to skip processing for types that we know * can not be (i.e. are never consider to be) beans: * things like primitives, Arrays, Enums, and proxy types. *<p> * Note that usually we shouldn't really be getting these sort of * types anyway; but better safe than sorry. */ protected boolean isPotentialBeanType(Class<?> type) { return (ClassUtil.canBeABeanType(type) == null) && !ClassUtil.isProxyType(type); } /** * Method used to collect all actual serializable properties. * Can be overridden to implement custom detection schemes.

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std; import java.io.File; import java.io.IOException; import java.lang.reflect.Type; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.JavaType; import com.fasterxml.jackson.databind.JsonMappingException; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.SerializerProvider; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper; /** * For now, File objects get serialized by just outputting * absolute (but not canonical) name as String value */ @SuppressWarnings("serial") public class FileSerializer extends StdScalarSerializer<File> { public FileSerializer() { super(File.class); } @Override public void serialize(File value, JsonGenerator jgen, SerializerProvider provider) throws IOException { jgen.writeString(value.getAbsolutePath()); } @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) { return createSchemaNode("string", true); } @Override public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException { visitor.expectStringFormat(typeHint); } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std; import java.io.IOException; import java.net.InetAddress; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.SerializerProvider; import com.fasterxml.jackson.databind.jsontype.TypeSerializer; /** * Simple serializer for {@link java.net.InetAddress}. Main complexity is * with registration, since same serializer is to be used for sub-classes. */ @SuppressWarnings("serial") public class InetAddressSerializer extends StdScalarSerializer<InetAddress> { public InetAddressSerializer() { super(InetAddress.class); } @Override public void serialize(InetAddress value, JsonGenerator jgen, SerializerProvider provider) throws IOException { // Ok: get textual description; choose "more specific" part String str = value.toString().trim(); int ix = str.indexOf('/'); if (ix >= 0) { if (ix == 0) { // missing host name; use address str = str.substring(1); } else { // otherwise use name str = str.substring(0, ix); } } jgen.writeString(str); } @Override public void serializeWithType(InetAddress value, JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer) throws IOException, JsonGenerationException { // Better ensure we don't use specific sub-classes... typeSer.writeTypePrefixForScalar(value, jgen, InetAddress.class); serialize(value, jgen, provider); typeSer.writeTypeSuffixForScalar(value, jgen); } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> usable, which may be * the same event as the one it pointed to upon call). *<p> * Note that this method is never called for JSON null literal, * and thus deserializers need (and should) not check for it. * * @param p Parsed used for reading JSON content * @param ctxt Context that can be used to access information about * this deserialization activity. * * @return Deserialized value */ public abstract T deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException; /** * Alternate deserialization method (compared to the most commonly * used, {@link #deserialize(JsonParser, DeserializationContext)}), * which takes in initialized value instance, to be * configured and/or populated by deserializer. * Method is not necessarily used (or supported) by all types * (it will not work for immutable types, for obvious reasons): * most commonly it is used for Collections and Maps. * It may be used both with "updating readers" (for POJOs) and * when Collections and Maps use "getter as setter". *<p> * Default implementation just throws * {@link UnsupportedOperationException}, to indicate that types * that do not explicitly add support do not necessarily support * update-existing-value operation (esp. immutable types) */ public T deserialize(JsonParser p, DeserializationContext ctxt, T intoValue) throws IOException, JsonProcessingException { throw new UnsupportedOperationException("Can not update object of type " +intoValue.getClass().getName()+" (by deserializer of type "+getClass().getName()+")"); } /** * Deserialization called when type being deserialized is defined to * contain additional type identifier, to allow for correctly * instantiating correct subtype. This can be due to annotation on * type (or its supertype), or due to global settings without * annotations. *<p> * Default implementation may work for some types, but ideally subclasses * should not rely on current default implementation. * Implementation is mostly provided to avoid compilation errors with older * code. * * @param typeDeserializer Deserializer to use for handling type information */ public Object deserializeWithType(JsonParser p, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> Some standard deserializers (most notably * {@link com.fasterxml.jackson.databind.deser.BeanDeserializer}) * do implement this feature, and may return reader instance, depending on exact * configuration of instance (which is based on type, and referring property). * * @return ObjectIdReader used for resolving possible Object Identifier * value, instead of full value serialization, if deserializer can do that; * null if no Object Id is expected. * * @since 2.0 */ public ObjectIdReader getObjectIdReader() { return null; } /** * Accessor that can be used to determine if this deserializer uses * another deserializer for actual deserialization, by delegating * calls. If so, will return immediate delegate (which itself may * delegate to further deserializers); otherwise will return null. * * @return Deserializer this deserializer delegates calls to, if null; * null otherwise. * * @since 2.1 */ public JsonDeserializer<?> getDelegatee() { return null; } /** * Method needed by {@link BeanDeserializerFactory} to properly link * managed- and back-reference pairs. * * @since 2.2 (was moved out of <code>BeanDeserializerBase</code>) */ public SettableBeanProperty findBackReference(String refName) { throw new IllegalArgumentException("Can not handle managed/back reference '"+refName +"': type: value deserializer of type "+getClass().getName()+" does not support them"); } /* /********************************************************** /* Helper classes /********************************************************** */ /** * This marker class is only to be used with annotations, to * indicate that <b>no deserializer is configured</b>. *<p> * Specifically, this class is to be used as the marker for * annotation {@link com.fasterxml.jackson.databind.annotation.JsonDeserialize} */ public abstract static class None extends JsonDeserializer<Object> { private None() { } // not to be instantiated } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser.std; import java.io.IOException; import com.fasterxml.jackson.core.JsonParser; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.deser.ContextualDeserializer; import com.fasterxml.jackson.databind.deser.ResolvableDeserializer; import com.fasterxml.jackson.databind.jsontype.TypeDeserializer; import com.fasterxml.jackson.databind.util.Converter; /** * Deserializer implementation where given Java type is first deserialized * by a standard Jackson deserializer into a delegate type; and then * this delegate type is converted using a configured * {@link Converter} into desired target type. * Common delegate types to use are {@link java.util.Map} * and {@link com.fasterxml.jackson.databind.JsonNode}. *<p> * Note that although types (delegate, target) may be related, they must not be same; trying * to do this will result in an exception. *<p> * Since 2.5 There is {@link StdNodeBasedDeserializer} that is a simplified version * for cases where intermediate type is {@link JsonNode} * * @param <T> Target type to convert to, from delegate type * * @since 2.1 * * @see StdNodeBasedDeserializer * @see Converter */ public class StdDelegatingDeserializer<T> extends StdDeserializer<T> implements ContextualDeserializer, ResolvableDeserializer { private static final long serialVersionUID = 1L; protected final Converter<Object,T> _converter; /** * Fully resolved delegate type, with generic information if any available. */ protected final JavaType _delegateType; /** * Underlying serializer for type <code>T<.code>. */ protected final JsonDeserializer<Object> _delegateDeserializer; /* /********************************************************** /* Life-cycle /********************************************************** */ @SuppressWarnings("unchecked") public StdDelegatingDeserializer(Converter<?,T> converter) { super(Object.class); _converter = (Converter<Object,T>)converter; _delegateType = null; _delegateDeserializer = null; }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> @SuppressWarnings("unchecked") public StdDelegatingDeserializer(Converter<Object,T> converter, JavaType delegateType, JsonDeserializer<?> delegateDeserializer) { super(delegateType); _converter = converter; _delegateType = delegateType; _delegateDeserializer = (JsonDeserializer<Object>) delegateDeserializer; } /** * @since 2.5 */ protected StdDelegatingDeserializer(StdDelegatingDeserializer<T> src) { super(src); _converter = src._converter; _delegateType = src._delegateType; _delegateDeserializer = src._delegateDeserializer; } /** * Method used for creating resolved contextual instances. Must be * overridden when sub-classing. */ protected StdDelegatingDeserializer<T> withDelegate(Converter<Object,T> converter, JavaType delegateType, JsonDeserializer<?> delegateDeserializer) { if (getClass() != StdDelegatingDeserializer.class) { throw new IllegalStateException("Sub-class "+getClass().getName()+" must override 'withDelegate'"); } return new StdDelegatingDeserializer<T>(converter, delegateType, delegateDeserializer); } /* /********************************************************** /* Contextualization /********************************************************** */ @Override public void resolve(DeserializationContext ctxt) throws JsonMappingException { if (_delegateDeserializer != null && _delegateDeserializer instanceof ResolvableDeserializer) { ((ResolvableDeserializer) _delegateDeserializer).resolve(ctxt); } } @Override public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException { // First: if already got serializer to delegate to, contextualize it: if (_delegateDeserializer != null) { JsonDeserializer<?> deser = ctxt.handleSecondaryContextualization(_delegateDeserializer, property, _delegateType); if (deser != _delegateDeserializer) { return withDelegate(_converter, _delegateType, deser); } return this; } // Otherwise: figure out what is the fully generic delegate type, then find deserializer JavaType delegateType = _converter.getInputType(ctxt.getTypeFactory()); return withDelegate(_converter, delegateType, ctxt.findContextualValueDeserializer(delegateType, property)); } /* /********************************************************** /* Accessors /********************************************************** */ @Override public JsonDeserializer

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.impl; import java.io.IOException; import java.util.Iterator; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.annotation.JacksonStdImpl; import com.fasterxml.jackson.databind.jsontype.TypeSerializer; import com.fasterxml.jackson.databind.ser.ContainerSerializer; import com.fasterxml.jackson.databind.ser.std.AsArraySerializerBase; @SuppressWarnings("serial") @JacksonStdImpl public class IteratorSerializer extends AsArraySerializerBase<Iterator<?>> { public IteratorSerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts, BeanProperty property) { super(Iterator.class, elemType, staticTyping, vts, property, null); } public IteratorSerializer(IteratorSerializer src, BeanProperty property, TypeSerializer vts, JsonSerializer<?> valueSerializer) { super(src, property, vts, valueSerializer); } @Override public boolean isEmpty(SerializerProvider prov, Iterator<?> value) { return (value == null) || !value.hasNext(); } @Override public boolean hasSingleElement(Iterator<?> value) { // no really good way to determine (without consuming iterator), so: return false; } @Override public ContainerSerializer<?> _withValueTypeSerializer(TypeSerializer vts) { return new IteratorSerializer(_elementType, _staticTyping, vts, _property); } @Override public IteratorSerializer withResolved(BeanProperty property, TypeSerializer vts, JsonSerializer<?> elementSerializer) { return new IteratorSerializer(this, property, vts, elementSerializer); } @Override public final void serialize(Iterator<?> value, JsonGenerator jgen, SerializerProvider provider) throws IOException { if (provider.isEnabled(SerializationFeature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED) && hasSingleElement(value)) { serializeContents(value, jgen, provider); return; } jgen.writeStartArray(); serializeContents(value, jgen, provider); jgen.writeEndArray(); } @Override public void serializeContents(Iterator<?> value, JsonGenerator jgen, Serializer

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>Provider provider) throws IOException { if (value.hasNext()) { final TypeSerializer typeSer = _valueTypeSerializer; JsonSerializer<Object> prevSerializer = null; Class<?> prevClass = null; do { Object elem = value.next(); if (elem == null) { provider.defaultSerializeNull(jgen); continue; } JsonSerializer<Object> currSerializer = _elementSerializer; if (currSerializer == null) { // Minor optimization to avoid most lookups: Class<?> cc = elem.getClass(); if (cc == prevClass) { currSerializer = prevSerializer; } else { currSerializer = provider.findValueSerializer(cc, _property); prevSerializer = currSerializer; prevClass = cc; } } if (typeSer == null) { currSerializer.serialize(elem, jgen, provider); } else { currSerializer.serializeWithType(elem, jgen, provider, typeSer); } } while (value.hasNext()); } } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> = findSerializationType(am, defaultUseStaticTyping, declaredType); // Container types can have separate type serializers for content (value / element) type if (contentTypeSer != null) { /* 04-Feb-2010, tatu: Let's force static typing for collection, if there is * type information for contents. Should work well (for JAXB case); can be * revisited if this causes problems. */ if (serializationType == null) { // serializationType = TypeFactory.type(am.getGenericType(), _beanDesc.getType()); serializationType = declaredType; } JavaType ct = serializationType.getContentType(); /* 03-Sep-2010, tatu: This is somehow related to [JACKSON-356], but I don't completely * yet understand how pieces fit together. Still, better to be explicit than rely on * NPE to indicate an issue... */ if (ct == null) { throw new IllegalStateException("Problem trying to create BeanPropertyWriter for property '" +propDef.getName()+"' (of type "+_beanDesc.getType()+"); serialization type "+serializationType+" has no content"); } serializationType = serializationType.withContentTypeHandler(contentTypeSer); ct = serializationType.getContentType(); } Object valueToSuppress = null; boolean suppressNulls = false; JsonInclude.Include inclusion = propDef.findInclusion(); if (inclusion == null) { inclusion = _defaultInclusion; } if (inclusion != null) { switch (inclusion) { case NON_DEFAULT: valueToSuppress = getDefaultValue(propDef.getName(), am); if (valueToSuppress == null) { suppressNulls = true; } else { // [JACKSON-531]: Allow comparison of arrays too... if (valueToSuppress.getClass().isArray()) { valueToSuppress = ArrayBuilders.getArrayComparator(valueToSuppress); } } break; case NON_EMPTY: // always suppress nulls suppressNulls = true; // but possibly also 'empty' values: valueToSuppress = BeanPropertyWriter.MARKER_FOR_EMPTY; break; case NON_NULL: suppressNull

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>Member member) { Object defaultBean = getDefaultBean(); try { return member.getValue(defaultBean); } catch (Exception e) { return _throwWrapped(e, name, defaultBean); } } /* /********************************************************** /* Helper methods for exception handling /********************************************************** */ protected Object _throwWrapped(Exception e, String propName, Object defaultBean) { Throwable t = e; while (t.getCause() != null) { t = t.getCause(); } if (t instanceof Error) throw (Error) t; if (t instanceof RuntimeException) throw (RuntimeException) t; throw new IllegalArgumentException("Failed to get property '"+propName+"' of default "+defaultBean.getClass().getName()+" instance"); } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser.std; import java.io.IOException; import java.lang.reflect.Method; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.deser.ContextualDeserializer; import com.fasterxml.jackson.databind.introspect.AnnotatedMethod; import com.fasterxml.jackson.databind.jsontype.TypeDeserializer; import com.fasterxml.jackson.databind.util.ClassUtil; import com.fasterxml.jackson.databind.util.EnumResolver; /** * Deserializer class that can deserialize instances of * specified Enum class from Strings and Integers. */ public class EnumDeserializer extends StdScalarDeserializer<Enum<?>> { private static final long serialVersionUID = 1L; protected final EnumResolver<?> _resolver; public EnumDeserializer(EnumResolver<?> res) { super(Enum.class); _resolver = res; } /** * Factory method used when Enum instances are to be deserialized * using a creator (static factory method) * * @return Deserializer based on given factory method, if type was suitable; * null if type can not be used */ public static JsonDeserializer<?> deserializerForCreator(DeserializationConfig config, Class<?> enumClass, AnnotatedMethod factory) { // note: caller has verified there's just one arg; but we must verify its type Class<?> paramClass = factory.getRawParameterType(0); if (config.canOverrideAccessModifiers()) { ClassUtil.checkAndFixAccess(factory.getMember()); } return new FactoryBasedDeserializer(enumClass, factory, paramClass); } /* /********************************************************** /* Default JsonDeserializer implementation /********************************************************** */ /** * Because of costs associated with constructing Enum resolvers, * let's cache instances by default. */ @Override public boolean isCachable() { return true; } @Override public Enum<?> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException { JsonToken curr = jp.getCurrentToken(); // Usually should just get string value: if (curr == JsonToken.VALUE_STRING || curr == JsonToken.FIELD_NAME) { String name = jp.getText();

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>(); // Issue#381 if (curr == JsonToken.START_ARRAY && ctxt.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS)) { jp.nextToken(); final Enum<?> parsed = deserialize(jp, ctxt); curr = jp.nextToken(); if (curr != JsonToken.END_ARRAY) { throw ctxt.wrongTokenException(jp, JsonToken.END_ARRAY, "Attempted to unwrap single value array for single '" + _resolver.getEnumClass().getName() + "' value but there was more than a single value in the array"); } return parsed; } throw ctxt.mappingException(_resolver.getEnumClass()); } protected void _checkFailOnNumber(DeserializationContext ctxt) throws IOException { if (ctxt.isEnabled(DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS)) { throw ctxt.mappingException("Not allowed to deserialize Enum value out of JSON number (disable DeserializationConfig.DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS to allow)"); } } /* /********************************************************** /* Additional helper classes /********************************************************** */ /** * Deserializer that uses a single-String static factory method * for locating Enum values by String id. */ protected static class FactoryBasedDeserializer extends StdDeserializer<Object> implements ContextualDeserializer { private static final long serialVersionUID = 1; // Marker type; null if String expected; otherwise numeric wrapper protected final Class<?> _inputType; protected final Method _factory; protected final JsonDeserializer<?> _deser; public FactoryBasedDeserializer(Class<?> cls, AnnotatedMethod f, Class<?> inputType) { super(cls); _factory = f.getAnnotated(); _inputType = inputType; _deser = null; } protected FactoryBasedDeserializer(FactoryBasedDeserializer base, JsonDeserializer<?> deser) { super(base._valueClass); _inputType = base._inputType; _factory = base._factory; _deser = deser; } @Override public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException { if ((_deser == null) && (_inputType != String.class)) { return new FactoryBased

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std; import java.io.IOException; import java.lang.reflect.Type; import java.util.*; import com.fasterxml.jackson.annotation.JsonFormat; import com.fasterxml.jackson.annotation.JsonFormat.Shape; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.annotation.JacksonStdImpl; import com.fasterxml.jackson.databind.introspect.Annotated; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonIntegerFormatVisitor; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonStringFormatVisitor; import com.fasterxml.jackson.databind.node.ArrayNode; import com.fasterxml.jackson.databind.node.ObjectNode; import com.fasterxml.jackson.databind.ser.ContextualSerializer; import com.fasterxml.jackson.databind.util.EnumValues; /** * Standard serializer used for {@link java.lang.Enum} types. *<p> * Based on {@link StdScalarSerializer} since the JSON value is * scalar (String). * * @author tatu */ @JacksonStdImpl public class EnumSerializer extends StdScalarSerializer<Enum<?>> implements ContextualSerializer { private static final long serialVersionUID = 1L; /** * This map contains pre-resolved values (since there are ways * to customize actual String constants to use) to use as * serializations. */ protected final EnumValues _values; /** * Flag that is set if we statically know serialization choice * between index and textual format (null if it needs to be dynamically * checked). * * @since 2.1 */ protected final Boolean _serializeAsIndex; /* /********************************************************** /* Construction, initialization /********************************************************** */ /** * @deprecated Since 2.1 */ @Deprecated public EnumSerializer(EnumValues v) { this(v, null); } public EnumSerializer(EnumValues v, Boolean serializeAsIndex) { super(Enum.class, false); _

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.type; import com.fasterxml.jackson.databind.JavaType; /** * Type that represents "true" Java Map types. */ public final class MapType extends MapLikeType { private static final long serialVersionUID = -811146779148281500L; /* /********************************************************** /* Life-cycle /********************************************************** */ private MapType(Class<?> mapType, JavaType keyT, JavaType valueT, Object valueHandler, Object typeHandler, boolean asStatic) { super(mapType, keyT, valueT, valueHandler, typeHandler, asStatic); } public static MapType construct(Class<?> rawType, JavaType keyT, JavaType valueT) { // nominally component types will be just Object.class return new MapType(rawType, keyT, valueT, null, null, false); } @Override protected JavaType _narrow(Class<?> subclass) { return new MapType(subclass, _keyType, _valueType, _valueHandler, _typeHandler, _asStatic); } @Override public JavaType narrowContentsBy(Class<?> contentClass) { // Can do a quick check first: if (contentClass == _valueType.getRawClass()) { return this; } return new MapType(_class, _keyType, _valueType.narrowBy(contentClass), _valueHandler, _typeHandler, _asStatic); } @Override public JavaType widenContentsBy(Class<?> contentClass) { if (contentClass == _valueType.getRawClass()) { return this; } return new MapType(_class, _keyType, _valueType.widenBy(contentClass), _valueHandler, _typeHandler, _asStatic); } @Override public JavaType narrowKey(Class<?> keySubclass) { // Can do a quick check first: if (keySubclass == _keyType.getRawClass()) { return this; } return new MapType(_class, _keyType.narrowBy(keySubclass), _valueType, _valueHandler, _typeHandler, _asStatic); } @Override public JavaType widenKey(Class

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS><?> keySubclass) { // Can do a quick check first: if (keySubclass == _keyType.getRawClass()) { return this; } return new MapType(_class, _keyType.widenBy(keySubclass), _valueType, _valueHandler, _typeHandler, _asStatic); } @Override public MapType withTypeHandler(Object h) { return new MapType(_class, _keyType, _valueType, _valueHandler, h, _asStatic); } @Override public MapType withContentTypeHandler(Object h) { return new MapType(_class, _keyType, _valueType.withTypeHandler(h), _valueHandler, _typeHandler, _asStatic); } @Override public MapType withValueHandler(Object h) { return new MapType(_class, _keyType, _valueType, h, _typeHandler, _asStatic); } @Override public MapType withContentValueHandler(Object h) { return new MapType(_class, _keyType, _valueType.withValueHandler(h), _valueHandler, _typeHandler, _asStatic); } @Override public MapType withStaticTyping() { if (_asStatic) { return this; } return new MapType(_class, _keyType.withStaticTyping(), _valueType.withStaticTyping(), _valueHandler, _typeHandler, true); } /* /********************************************************** /* Overridden accessors /********************************************************** */ @Override public Class<?> getParameterSource() { return java.util.Map.class; } /* /********************************************************** /* Extended API /********************************************************** */ @Override public MapType withKeyTypeHandler(Object h) { return new MapType(_class, _keyType.withTypeHandler(h), _valueType, _valueHandler, _typeHandler, _asStatic); } @Override public MapType withKeyValueHandler(Object h) { return new MapType(_class, _keyType.withValueHandler(h), _valueType, _valueHandler, _typeHandler, _asStatic); } /* /********************************************************** /* Standard methods /********************************************************** */ @Override public String toString() { return

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> "[map type; class "+_class.getName()+", "+_keyType+" -> "+_valueType+"]"; } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std; import java.io.IOException; import java.lang.reflect.Type; import java.math.BigDecimal; import java.math.BigInteger; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.core.JsonParser; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.annotation.JacksonStdImpl; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonIntegerFormatVisitor; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonNumberFormatVisitor; /** * As a fallback, we may need to use this serializer for other * types of {@link Number}s: both custom types and "big" numbers * like {@link BigInteger} and {@link BigDecimal}. */ @JacksonStdImpl @SuppressWarnings("serial") public class NumberSerializer extends StdScalarSerializer<Number> { /** * Static instance that is only to be used for {@link java.lang.Number}. */ public final static NumberSerializer instance = new NumberSerializer(Number.class); protected final boolean _isInt; @Deprecated // since 2.5 public NumberSerializer() { super(Number.class); _isInt = false; } /** * @since 2.5 */ public NumberSerializer(Class<? extends Number> rawType) { super(rawType, false); // since this will NOT be constructed for Integer or Long, only case is: _isInt = (rawType == BigInteger.class); } @Override public void serialize(Number value, JsonGenerator jgen, SerializerProvider provider) throws IOException { // should mostly come in as one of these two: if (value instanceof BigDecimal) { jgen.writeNumber((BigDecimal) value); } else if (value instanceof BigInteger) { jgen.writeNumber((BigInteger) value); /* These shouldn't match (as there are more specific ones), * but just to be sure: */ } else if (value instanceof Integer) { jgen.writeNumber(value.intValue()); } else if (value instanceof Long)

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> { jgen.writeNumber(value.longValue()); } else if (value instanceof Double) { jgen.writeNumber(value.doubleValue()); } else if (value instanceof Float) { jgen.writeNumber(value.floatValue()); } else if ((value instanceof Byte) || (value instanceof Short)) { jgen.writeNumber(value.intValue()); // doesn't need to be cast to smaller numbers } else { // We'll have to use fallback "untyped" number write method jgen.writeNumber(value.toString()); } } @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) { return createSchemaNode(_isInt ? "integer" : "number", true); } @Override public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException { if (_isInt) { JsonIntegerFormatVisitor v2 = visitor.expectIntegerFormat(typeHint); if (v2 != null) { v2.numberType(JsonParser.NumberType.BIG_INTEGER); } } else { JsonNumberFormatVisitor v2 = visitor.expectNumberFormat(typeHint); if (v2 != null) { Class<?> h = handledType(); if (h == BigDecimal.class) { v2.numberType(JsonParser.NumberType.BIG_DECIMAL); } // otherwise it's for Number... anything we could do there? } } } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.exc; import java.util.*; import com.fasterxml.jackson.core.JsonLocation; import com.fasterxml.jackson.core.JsonParser; import com.fasterxml.jackson.databind.JsonMappingException; /** * Specialized {@link JsonMappingException} sub-class specifically used * to indicate problems due to encountering a JSON property that could * not be mapped to an Object property (via getter, constructor argument * or field). */ public class UnrecognizedPropertyException extends PropertyBindingException { private static final long serialVersionUID = 1L; public UnrecognizedPropertyException(String msg, JsonLocation loc, Class<?> referringClass, String propName, Collection<Object> propertyIds) { super(msg, loc, referringClass, propName, propertyIds); } /** * Factory method used for constructing instances of this exception type. * * @param jp Underlying parser used for reading input being used for data-binding * @param fromObjectOrClass Reference to either instance of problematic type ( * if available), or if not, type itself * @param propertyName Name of unrecognized property * @param propertyIds (optional, null if not available) Set of properties that * type would recognize, if completely known: null if set can not be determined. */ public static UnrecognizedPropertyException from(JsonParser jp, Object fromObjectOrClass, String propertyName, Collection<Object> propertyIds) { if (fromObjectOrClass == null) { throw new IllegalArgumentException(); } Class<?> ref; if (fromObjectOrClass instanceof Class<?>) { ref = (Class<?>) fromObjectOrClass; } else { ref = fromObjectOrClass.getClass(); } String msg = "Unrecognized field \""+propertyName+"\" (class "+ref.getName()+"), not marked as ignorable"; UnrecognizedPropertyException e = new UnrecognizedPropertyException(msg, jp.getCurrentLocation(), ref, propertyName, propertyIds); // but let's also ensure path includes this last (missing) segment e.prependPath(fromObjectOrClass, propertyName); return e; } /** * @deprecated Since 2.3, use {@link #getPropertyName} instead. */ @Deprecated

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser.std; import com.fasterxml.jackson.core.JsonLocation; import com.fasterxml.jackson.databind.DeserializationConfig; import com.fasterxml.jackson.databind.DeserializationContext; import com.fasterxml.jackson.databind.JavaType; import com.fasterxml.jackson.databind.PropertyMetadata; import com.fasterxml.jackson.databind.PropertyName; import com.fasterxml.jackson.databind.deser.CreatorProperty; import com.fasterxml.jackson.databind.deser.ValueInstantiator; /** * For {@link JsonLocation}, we should be able to just implement * {@link ValueInstantiator} (not that explicit one would be very * hard but...) */ public class JsonLocationInstantiator extends ValueInstantiator { @Override public String getValueTypeDesc() { return JsonLocation.class.getName(); } @Override public boolean canCreateFromObjectWith() { return true; } @Override public CreatorProperty[] getFromObjectArguments(DeserializationConfig config) { JavaType intType = config.constructType(Integer.TYPE); JavaType longType = config.constructType(Long.TYPE); return new CreatorProperty[] { creatorProp("sourceRef", config.constructType(Object.class), 0), creatorProp("byteOffset", longType, 1), creatorProp("charOffset", longType, 2), creatorProp("lineNr", intType, 3), creatorProp("columnNr", intType, 4) }; } private static CreatorProperty creatorProp(String name, JavaType type, int index) { return new CreatorProperty(new PropertyName(name), type, null, null, null, null, index, null, PropertyMetadata.STD_REQUIRED); } @Override public Object createFromObjectWith(DeserializationContext ctxt, Object[] args) { return new JsonLocation(args[0], _long(args[1]), _long(args[2]), _int(args[3]), _int(args[4])); } private final static long _long(Object o) { return (o == null) ? 0L : ((Number) o).longValue(); } private final static int _int(Object o) { return

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> } ReadableObjectId entry = new ReadableObjectId(key); entry.setResolver(resolver); _objectIds.put(key, entry); return entry; } @Deprecated // since 2.4 @Override public ReadableObjectId findObjectId(Object id, ObjectIdGenerator<?> gen) { return findObjectId(id, gen, new SimpleObjectIdResolver()); } @Override public void checkUnresolvedObjectId() throws UnresolvedForwardReference { if (_objectIds == null) { return; } // 29-Dec-2014, tatu: As per [databind#299], may also just let unresolved refs be... if (!isEnabled(DeserializationFeature.FAIL_ON_UNRESOLVED_OBJECT_IDS)) { return; } UnresolvedForwardReference exception = null; for (Entry<IdKey,ReadableObjectId> entry : _objectIds.entrySet()) { ReadableObjectId roid = entry.getValue(); if (roid.hasReferringProperties()) { if (exception == null) { exception = new UnresolvedForwardReference("Unresolved forward references for: "); } for (Iterator<Referring> iterator = roid.referringProperties(); iterator.hasNext(); ) { Referring referring = iterator.next(); exception.addUnresolvedId(roid.getKey().key, referring.getBeanType(), referring.getLocation()); } } } if (exception != null) { throw exception; } } /* /********************************************************** /* Abstract methods impls, other factory methods /********************************************************** */ @SuppressWarnings("unchecked") @Override public JsonDeserializer<Object> deserializerInstance(Annotated ann, Object deserDef) throws JsonMappingException { if (deserDef == null) { return null; } JsonDeserializer<?> deser; if (deserDef instanceof JsonDeserializer) { deser = (JsonDeserializer<?>) deserDef; } else { /* Alas, there's no way to force return type of "either class * X or Y" -- need to throw an exception after the fact */ if (!(deserDef instanceof Class)) { throw new IllegalStateException("AnnotationIntrospector returned deserializer definition of type "+deserDef.getClass().getName()+"; expected type JsonDeserializer or

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> Class<JsonDeserializer> instead"); } Class<?> deserClass = (Class<?>)deserDef; // there are some known "no class" markers to consider too: if (deserClass == JsonDeserializer.None.class || ClassUtil.isBogusClass(deserClass)) { return null; } if (!JsonDeserializer.class.isAssignableFrom(deserClass)) { throw new IllegalStateException("AnnotationIntrospector returned Class "+deserClass.getName()+"; expected Class<JsonDeserializer>"); } HandlerInstantiator hi = _config.getHandlerInstantiator(); deser = (hi == null) ? null : hi.deserializerInstance(_config, ann, deserClass); if (deser == null) { deser = (JsonDeserializer<?>) ClassUtil.createInstance(deserClass, _config.canOverrideAccessModifiers()); } } // First: need to resolve if (deser instanceof ResolvableDeserializer) { ((ResolvableDeserializer) deser).resolve(this); } return (JsonDeserializer<Object>) deser; } @Override public final KeyDeserializer keyDeserializerInstance(Annotated ann, Object deserDef) throws JsonMappingException { if (deserDef == null) { return null; } KeyDeserializer deser; if (deserDef instanceof KeyDeserializer) { deser = (KeyDeserializer) deserDef; } else { if (!(deserDef instanceof Class)) { throw new IllegalStateException("AnnotationIntrospector returned key deserializer definition of type " +deserDef.getClass().getName() +"; expected type KeyDeserializer or Class<KeyDeserializer> instead"); } Class<?> deserClass = (Class<?>)deserDef; // there are some known "no class" markers to consider too: if (deserClass == KeyDeserializer.None.class || ClassUtil.isBogusClass(deserClass)) { return null; } if (!KeyDeserializer.class.isAssignableFrom(deserClass)) { throw new IllegalStateException("AnnotationIntrospector returned Class "+deserClass.getName() +"; expected Class<KeyDeserializer>"); } HandlerInstantiator hi = _config.getHandlerInstantiator(); deser = (hi == null) ? null : hi.keyDeserializerInstance(_config, ann, deserClass); if

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> (deser == null) { deser = (KeyDeserializer) ClassUtil.createInstance(deserClass, _config.canOverrideAccessModifiers()); } } // First: need to resolve if (deser instanceof ResolvableDeserializer) { ((ResolvableDeserializer) deser).resolve(this); } return deser; } /* /********************************************************** /* Extended API /********************************************************** */ /** * Fluent factory method used for constructing a blueprint instance * with different factory */ public abstract DefaultDeserializationContext with(DeserializerFactory factory); /** * Method called to create actual usable per-deserialization * context instance. */ public abstract DefaultDeserializationContext createInstance( DeserializationConfig config, JsonParser jp, InjectableValues values); /* /********************************************************** /* And then the concrete implementation class /********************************************************** */ /** * Actual full concrete implementation */ public final static class Impl extends DefaultDeserializationContext { private static final long serialVersionUID = 1L; /** * Default constructor for a blueprint object, which will use the standard * {@link DeserializerCache}, given factory. */ public Impl(DeserializerFactory df) { super(df, null); } protected Impl(Impl src, DeserializationConfig config, JsonParser jp, InjectableValues values) { super(src, config, jp, values); } protected Impl(Impl src) { super(src); } protected Impl(Impl src, DeserializerFactory factory) { super(src, factory); } @Override public DefaultDeserializationContext copy() { if (getClass() != Impl.class) { return super.copy(); } return new Impl(this); } @Override public DefaultDeserializationContext createInstance(DeserializationConfig config, JsonParser jp, InjectableValues values) { return new Impl(this, config, jp, values); } @Override public DefaultDeserializationContext with(DeserializerFactory factory) { return new Impl(this, factory); } } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> prop = it.next(); if (prop.getName().equals(propName)) { it.remove(); return true; } } return false; } /* /********************************************************** /* Simple accessors from BeanDescription /********************************************************** */ @Override public AnnotatedClass getClassInfo() { return _classInfo; } @Override public ObjectIdInfo getObjectIdInfo() { return _objectIdInfo; } @Override public List<BeanPropertyDefinition> findProperties() { return _properties; } @Override public AnnotatedMethod findJsonValueMethod() { return _jsonValueMethod; } @Override public Set<String> getIgnoredPropertyNames() { if (_ignoredPropertyNames == null) { return Collections.emptySet(); } return _ignoredPropertyNames; } @Override public boolean hasKnownClassAnnotations() { return _classInfo.hasAnnotations(); } @Override public Annotations getClassAnnotations() { return _classInfo.getAnnotations(); } @Override public TypeBindings bindingsForBeanType() { if (_bindings == null) { _bindings = new TypeBindings(_config.getTypeFactory(), _type); } return _bindings; } @Override public JavaType resolveType(java.lang.reflect.Type jdkType) { if (jdkType == null) { return null; } return bindingsForBeanType().resolveType(jdkType); } @Override public AnnotatedConstructor findDefaultConstructor() { return _classInfo.getDefaultConstructor(); } @Override public AnnotatedMethod findAnySetter() throws IllegalArgumentException { if (_anySetterMethod != null) { /* Also, let's be somewhat strict on how field name is to be * passed; String, Object make sense, others not * so much. */ /* !!! 18-May-2009, tatu: how about enums? Can add support if * requested; easy enough for devs to add support within * method. */ Class<?> type = _anySetterMethod.getRawParameterType(0); if (type != String.class && type != Object.class) { throw new IllegalArgumentException("Invalid 'any-setter' annotation on method "+_anySetterMethod.getName()+"

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>(): first argument not of type String or Object, but "+type.getName()); } } return _anySetterMethod; } @Override public Map<Object, AnnotatedMember> findInjectables() { return _injectables; } @Override public List<AnnotatedConstructor> getConstructors() { return _classInfo.getConstructors(); } @Override public Object instantiateBean(boolean fixAccess) { AnnotatedConstructor ac = _classInfo.getDefaultConstructor(); if (ac == null) { return null; } if (fixAccess) { ac.fixAccess(); } try { return ac.getAnnotated().newInstance(); } catch (Exception e) { Throwable t = e; while (t.getCause() != null) { t = t.getCause(); } if (t instanceof Error) throw (Error) t; if (t instanceof RuntimeException) throw (RuntimeException) t; throw new IllegalArgumentException("Failed to instantiate bean of type "+_classInfo.getAnnotated().getName()+": ("+t.getClass().getName()+") "+t.getMessage(), t); } } /* /********************************************************** /* Simple accessors, extended /********************************************************** */ @Override public AnnotatedMethod findMethod(String name, Class<?>[] paramTypes) { return _classInfo.findMethod(name, paramTypes); } /* /********************************************************** /* General per-class annotation introspection /********************************************************** */ @Override public JsonFormat.Value findExpectedFormat(JsonFormat.Value defValue) { if (_annotationIntrospector != null) { JsonFormat.Value v = _annotationIntrospector.findFormat(_classInfo); if (v != null) { return v; } } return defValue; } /* /********************************************************** /* Introspection for serialization /********************************************************** */ @Override public Converter<Object,Object> findSerializationConverter() { if (_annotationIntrospector == null) { return null; } return _createConverter(_annotationIntrospector.findSerializationConverter(_classInfo)); } /** * Method for determining whether null properties should be written * out for a Bean of introspected type. This is based on global

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> * feature (lowest priority, passed as argument) * and per-class annotation (highest priority). */ @Override public JsonInclude.Include findSerializationInclusion(JsonInclude.Include defValue) { if (_annotationIntrospector == null) { return defValue; } return _annotationIntrospector.findSerializationInclusion(_classInfo, defValue); } @Override public JsonInclude.Include findSerializationInclusionForContent(JsonInclude.Include defValue) { if (_annotationIntrospector == null) { return defValue; } return _annotationIntrospector.findSerializationInclusionForContent(_classInfo, defValue); } /** * Method used to locate the method of introspected class that * implements {@link com.fasterxml.jackson.annotation.JsonAnyGetter}. * If no such method exists null is returned. * If more than one are found, an exception is thrown. */ @Override public AnnotatedMember findAnyGetter() throws IllegalArgumentException { if (_anyGetter != null) { /* For now let's require a Map; in future can add support for other * types like perhaps Iterable<Map.Entry>? */ Class<?> type = _anyGetter.getRawType(); if (!Map.class.isAssignableFrom(type)) { throw new IllegalArgumentException("Invalid 'any-getter' annotation on method "+_anyGetter.getName()+"(): return type is not instance of java.util.Map"); } } return _anyGetter; } @Override public Map<String,AnnotatedMember> findBackReferenceProperties() { HashMap<String,AnnotatedMember> result = null; // boolean hasIgnored = (_ignoredPropertyNames != null); for (BeanPropertyDefinition property : _properties) { /* 23-Sep-2014, tatu: As per [Databind#426], we _should_ try to avoid * calling accessor, as it triggers exception from seeming conflict. * But the problem is that _ignoredPropertyNames here only contains * ones ignored on per-property annotations, but NOT class annotations... * so commented out part does not work, alas */ /* if (hasIgnored && _ignoredPropertyNames.contains(property.getName())) { continue; }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>Class<?> expArgType : expArgTypes) { // And one that matches what we would pass in if (actualArgType.isAssignableFrom(expArgType)) { return am.getAnnotated(); } } } } return null; } protected boolean isFactoryMethod(AnnotatedMethod am) { /* First: return type must be compatible with the introspected class * (i.e. allowed to be sub-class, although usually is the same * class) */ Class<?> rt = am.getRawReturnType(); if (!getBeanClass().isAssignableFrom(rt)) { return false; } /* Also: must be a recognized factory method, meaning: * (a) marked with @JsonCreator annotation, or * (b) "valueOf" (at this point, need not be public) */ if (_annotationIntrospector.hasCreatorAnnotation(am)) { return true; } final String name = am.getName(); if ("valueOf".equals(name)) { return true; } // [Issue#208] Also accept "fromString()", if takes String or CharSequence if ("fromString".equals(name)) { if (1 == am.getParameterCount()) { Class<?> cls = am.getRawParameterType(0); if (cls == String.class || CharSequence.class.isAssignableFrom(cls)) { return true; } } } return false; } /** * @deprecated Since 2.4, use <code>findCreatorParameterNames()</code> instead. */ @Deprecated public List<String> findCreatorPropertyNames() { List<PropertyName> params = findCreatorParameterNames(); if (params.isEmpty()) { return Collections.emptyList(); } List<String> result = new ArrayList<String>(params.size()); for (PropertyName name : params) { result.add(name.getSimpleName()); } return result; } /** * @deprecated Since 2.5, does not seem to be used at all. */ @Deprecated public List<PropertyName> findCreatorParameterNames() { for (int i = 0; i < 2; ++i) { List<? extends AnnotatedWithParams> l = (i == 0) ? getConstructors

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> logical property name as key, and * matching field as value. */ public LinkedHashMap<String,AnnotatedField> _findPropertyFields( Collection<String> ignoredProperties, boolean forSerialization) { LinkedHashMap<String,AnnotatedField> results = new LinkedHashMap<String,AnnotatedField>(); for (BeanPropertyDefinition property : _properties) { AnnotatedField f = property.getField(); if (f != null) { String name = property.getName(); if (ignoredProperties != null) { if (ignoredProperties.contains(name)) { continue; } } results.put(name, f); } } return results; } /* /********************************************************** /* Helper methods, other /********************************************************** */ @SuppressWarnings("unchecked") public Converter<Object,Object> _createConverter(Object converterDef) { if (converterDef == null) { return null; } if (converterDef instanceof Converter<?,?>) { return (Converter<Object,Object>) converterDef; } if (!(converterDef instanceof Class)) { throw new IllegalStateException("AnnotationIntrospector returned Converter definition of type " +converterDef.getClass().getName()+"; expected type Converter or Class<Converter> instead"); } Class<?> converterClass = (Class<?>)converterDef; // there are some known "no class" markers to consider too: if (converterClass == Converter.None.class || ClassUtil.isBogusClass(converterClass)) { return null; } if (!Converter.class.isAssignableFrom(converterClass)) { throw new IllegalStateException("AnnotationIntrospector returned Class " +converterClass.getName()+"; expected Class<Converter>"); } HandlerInstantiator hi = _config.getHandlerInstantiator(); Converter<?,?> conv = (hi == null) ? null : hi.converterInstance(_config, _classInfo, converterClass); if (conv == null) { conv = (Converter<?,?>) ClassUtil.createInstance(converterClass, _config.canOverrideAccessModifiers()); } return (Converter<Object,Object>) conv; } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> for example do not * support this method. */ public abstract void set(Object instance, Object value) throws IOException; /** * Method called to assign given value to this property, on * specified Object, and return whatever delegating accessor * returned (if anything) *<p> * Note: this is an optional operation, not supported by all * implementations, creator-backed properties for example do not * support this method. */ public abstract Object setAndReturn(Object instance, Object value) throws IOException; /** * This method is needed by some specialized bean deserializers, * and also called by some {@link #deserializeAndSet} implementations. *<p> * Pre-condition is that passed parser must point to the first token * that should be consumed to produce the value (the only value for * scalars, multiple for Objects and Arrays). *<p> * Note that this method is final for performance reasons: to override * functionality you must override other methods that call this method; * this method should also not be called directly unless you really know * what you are doing (and probably not even then). */ public final Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { JsonToken t = p.getCurrentToken(); if (t == JsonToken.VALUE_NULL) { return (_nullProvider == null) ? null : _nullProvider.nullValue(ctxt); } if (_valueTypeDeserializer != null) { return _valueDeserializer.deserializeWithType(p, ctxt, _valueTypeDeserializer); } return _valueDeserializer.deserialize(p, ctxt); } /* /********************************************************** /* Helper methods /********************************************************** */ /** * Method that takes in exception of any type, and casts or wraps it * to an IOException or its subclass. */ protected void _throwAsIOE(Exception e, Object value) throws IOException { if (e instanceof IllegalArgumentException) { String actType = (value == null) ? "[NULL]" : value.getClass().getName(); StringBuilder msg = new StringBuilder("Problem deserializing property '").append(getName()); msg.append("' (expected type: ").append(getType()); msg.append("; actual type: ").append(actType).append(")"); String origMsg = e.

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.introspect; import java.lang.reflect.Constructor; import java.lang.reflect.Method; /** * Helper class needed to be able to efficiently access class * member functions ({@link Method}s and {@link Constructor}s) * in {@link java.util.Map}s. */ public final class MemberKey { final static Class<?>[] NO_CLASSES = new Class<?>[0]; final String _name; final Class<?>[] _argTypes; public MemberKey(Method m) { this(m.getName(), m.getParameterTypes()); } public MemberKey(Constructor<?> ctor) { this("", ctor.getParameterTypes()); } public MemberKey(String name, Class<?>[] argTypes) { _name = name; _argTypes = (argTypes == null) ? NO_CLASSES : argTypes; } @Override public String toString() { return _name + "(" + _argTypes.length+"-args)"; } @Override public int hashCode() { return _name.hashCode() + _argTypes.length; } @Override public boolean equals(Object o) { if (o == this) return true; if (o == null) return false; if (o.getClass() != getClass()) { return false; } MemberKey other = (MemberKey) o; if (!_name.equals(other._name)) { return false; } Class<?>[] otherArgs = other._argTypes; int len = _argTypes.length; if (otherArgs.length != len) { return false; } for (int i = 0; i < len; ++i) { Class<?> type1 = otherArgs[i]; Class<?> type2 = _argTypes[i]; if (type1 == type2) { continue; } /* 23-Feb-2009, tatu: Are there any cases where we would have to * consider some narrowing conversions or such? For now let's * assume exact type match is enough */ /* 07-Apr-2009, tatu: Indeed there are (see [JACKSON-

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser.std; import java.io.IOException; import java.util.concurrent.atomic.AtomicReference; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.deser.ContextualDeserializer; import com.fasterxml.jackson.databind.jsontype.TypeDeserializer; public class AtomicReferenceDeserializer extends StdDeserializer<AtomicReference<?>> implements ContextualDeserializer { private static final long serialVersionUID = 1L; /** * Type of value that we reference */ protected final JavaType _referencedType; protected final TypeDeserializer _valueTypeDeserializer; protected final JsonDeserializer<?> _valueDeserializer; /** * @param referencedType Parameterization of this reference */ public AtomicReferenceDeserializer(JavaType referencedType) { this(referencedType, null, null); } public AtomicReferenceDeserializer(JavaType referencedType, TypeDeserializer typeDeser, JsonDeserializer<?> deser) { super(AtomicReference.class); _referencedType = referencedType; _valueDeserializer = deser; _valueTypeDeserializer = typeDeser; } public AtomicReferenceDeserializer withResolved(TypeDeserializer typeDeser, JsonDeserializer<?> valueDeser) { return new AtomicReferenceDeserializer(_referencedType, typeDeser, valueDeser); } // Added in 2.3 @Override public AtomicReference<?> getNullValue() { return new AtomicReference<Object>(); } @Override public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException { JsonDeserializer<?> deser = _valueDeserializer; TypeDeserializer typeDeser = _valueTypeDeserializer; if (deser == null) { deser = ctxt.findContextualValueDeserializer(_referencedType, property); } if (typeDeser != null) { typeDeser = typeDeser.forProperty(property); } if (deser == _valueDeserializer && typeDeser == _valueTypeDeserializer) { return this; } return withResolved(typeDeser, deser); } @Override public AtomicReference<?> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException { /* 06-Nov-2013, tatu: Looks like the

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.util; import java.lang.reflect.*; import java.util.*; import com.fasterxml.jackson.databind.annotation.JacksonStdImpl; public final class ClassUtil { /* /********************************************************** /* Methods that deal with inheritance /********************************************************** */ /** * Method that will find all sub-classes and implemented interfaces * of a given class or interface. Classes are listed in order of * precedence, starting with the immediate super-class, followed by * interfaces class directly declares to implemented, and then recursively * followed by parent of super-class and so forth. * Note that <code>Object.class</code> is not included in the list * regardless of whether <code>endBefore</code> argument is defined or not. * * @param endBefore Super-type to NOT include in results, if any; when * encountered, will be ignored (and no super types are checked). */ public static List<Class<?>> findSuperTypes(Class<?> cls, Class<?> endBefore) { return findSuperTypes(cls, endBefore, new ArrayList<Class<?>>(8)); } public static List<Class<?>> findSuperTypes(Class<?> cls, Class<?> endBefore, List<Class<?>> result) { _addSuperTypes(cls, endBefore, result, false); return result; } private static void _addSuperTypes(Class<?> cls, Class<?> endBefore, Collection<Class<?>> result, boolean addClassItself) { if (cls == endBefore || cls == null || cls == Object.class) { return; } if (addClassItself) { if (result.contains(cls)) { // already added, no need to check supers return; } result.add(cls); } for (Class<?> intCls : cls.getInterfaces()) { _addSuperTypes(intCls, endBefore, result, true); } _addSuperTypes(cls.getSuperclass(), endBefore, result, true); } /* /********************************************************** /* Class type detection methods /********************************************************** */ /** * @return Null if class might be a bean; type String (that identifies * why it's not a bean) if not */ public static String

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>property) based serialization. */ public static boolean isProxyType(Class<?> type) { // As per [Issue#57], should NOT disqualify JDK proxy: /* // Then: well-known proxy (etc) classes if (Proxy.isProxyClass(type)) { return true; } */ String name = type.getName(); // Hibernate uses proxies heavily as well: if (name.startsWith("net.sf.cglib.proxy.") || name.startsWith("org.hibernate.proxy.")) { return true; } // Not one of known proxies, nope: return false; } /** * Helper method that checks if given class is a concrete one; * that is, not an interface or abstract class. */ public static boolean isConcrete(Class<?> type) { int mod = type.getModifiers(); return (mod & (Modifier.INTERFACE | Modifier.ABSTRACT)) == 0; } public static boolean isConcrete(Member member) { int mod = member.getModifiers(); return (mod & (Modifier.INTERFACE | Modifier.ABSTRACT)) == 0; } public static boolean isCollectionMapOrArray(Class<?> type) { if (type.isArray()) return true; if (Collection.class.isAssignableFrom(type)) return true; if (Map.class.isAssignableFrom(type)) return true; return false; } /* /********************************************************** /* Type name handling methods /********************************************************** */ /** * Helper method used to construct appropriate description * when passed either type (Class) or an instance; in latter * case, class of instance is to be used. */ public static String getClassDescription(Object classOrInstance) { if (classOrInstance == null) { return "unknown"; } Class<?> cls = (classOrInstance instanceof Class<?>) ? (Class<?>) classOrInstance : classOrInstance.getClass(); return cls.getName(); } /* /********************************************************** /* Class loading /********************************************************** */ public static Class<?> findClass(String className) throws ClassNotFoundException { // [JACKSON-597]: support primitive types (and void) if (className.indexOf('.') < 0) {

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> (cls == Float.TYPE) { return Float.valueOf(0.0f); } if (cls == Byte.TYPE) { return Byte.valueOf((byte) 0); } if (cls == Short.TYPE) { return Short.valueOf((short) 0); } if (cls == Character.TYPE) { return '\0'; } throw new IllegalArgumentException("Class "+cls.getName()+" is not a primitive type"); } /** * Helper method for finding wrapper type for given primitive type (why isn't * there one in JDK?) */ public static Class<?> wrapperType(Class<?> primitiveType) { if (primitiveType == Integer.TYPE) { return Integer.class; } if (primitiveType == Long.TYPE) { return Long.class; } if (primitiveType == Boolean.TYPE) { return Boolean.class; } if (primitiveType == Double.TYPE) { return Double.class; } if (primitiveType == Float.TYPE) { return Float.class; } if (primitiveType == Byte.TYPE) { return Byte.class; } if (primitiveType == Short.TYPE) { return Short.class; } if (primitiveType == Character.TYPE) { return Character.class; } throw new IllegalArgumentException("Class "+primitiveType.getName()+" is not a primitive type"); } /* /********************************************************** /* Access checking/handling methods /********************************************************** */ /** * Method called to check if we can use the passed method or constructor * (wrt access restriction -- public methods can be called, others * usually not); and if not, if there is a work-around for * the problem. */ public static void checkAndFixAccess(Member member) { // We know all members are also accessible objects... AccessibleObject ao = (AccessibleObject) member; /* 14-Jan-2009, tatu: It seems safe and potentially beneficial to * always to make it accessible (latter because it will force * skipping checks we have no use for...), so let's always call it. */ //if (!ao.isAccessible()) { try { ao.setAccessible(true

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> Class<?> ec = en.getClass(); if (ec.getSuperclass() != Enum.class) { ec = ec.getSuperclass(); } return (Class<? extends Enum<?>>) ec; } /** * Helper method that can be used to dynamically figure out formal * enumeration type (class) for given class of an enumeration value. * This is either class of enum instance (for "simple" enumerations), * or its superclass (for enums with instance fields or methods) */ @SuppressWarnings("unchecked") public static Class<? extends Enum<?>> findEnumType(Class<?> cls) { // enums with "body" are sub-classes of the formal type if (cls.getSuperclass() != Enum.class) { cls = cls.getSuperclass(); } return (Class<? extends Enum<?>>) cls; } /* /********************************************************** /* Jackson-specific stuff /********************************************************** */ /** * Method that can be called to determine if given Object is the default * implementation Jackson uses; as opposed to a custom serializer installed by * a module or calling application. Determination is done using * {@link JacksonStdImpl} annotation on handler (serializer, deserializer etc) * class. */ public static boolean isJacksonStdImpl(Object impl) { return (impl != null) && isJacksonStdImpl(impl.getClass()); } public static boolean isJacksonStdImpl(Class<?> implClass) { return (implClass.getAnnotation(JacksonStdImpl.class) != null); } public static boolean isBogusClass(Class<?> cls) { return (cls == Void.class || cls == Void.TYPE || cls == com.fasterxml.jackson.databind.annotation.NoClass.class); } public static boolean isNonStaticInnerClass(Class<?> cls) { return (cls.getEnclosingClass() != null) && !Modifier.isStatic(cls.getModifiers()); } /* /********************************************************** /* Helper classes /********************************************************** */ /** * Inner class used to contain gory details of how we can determine * details of instances of common JDK types like {@link EnumMap}s. */ private static class EnumTypeLocator { final

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> static EnumTypeLocator instance = new EnumTypeLocator(); private final Field enumSetTypeField; private final Field enumMapTypeField; private EnumTypeLocator() { /* JDK uses following fields to store information about actual Enumeration * type for EnumSets, EnumMaps... */ enumSetTypeField = locateField(EnumSet.class, "elementType", Class.class); enumMapTypeField = locateField(EnumMap.class, "elementType", Class.class); } @SuppressWarnings("unchecked") public Class<? extends Enum<?>> enumTypeFor(EnumSet<?> set) { if (enumSetTypeField != null) { return (Class<? extends Enum<?>>) get(set, enumSetTypeField); } throw new IllegalStateException("Can not figure out type for EnumSet (odd JDK platform?)"); } @SuppressWarnings("unchecked") public Class<? extends Enum<?>> enumTypeFor(EnumMap<?,?> set) { if (enumMapTypeField != null) { return (Class<? extends Enum<?>>) get(set, enumMapTypeField); } throw new IllegalStateException("Can not figure out type for EnumMap (odd JDK platform?)"); } private Object get(Object bean, Field field) { try { return field.get(bean); } catch (Exception e) { throw new IllegalArgumentException(e); } } private static Field locateField(Class<?> fromClass, String expectedName, Class<?> type) { Field found = null; // First: let's see if we can find exact match: Field[] fields = fromClass.getDeclaredFields(); for (Field f : fields) { if (expectedName.equals(f.getName()) && f.getType() == type) { found = f; break; } } // And if not, if there is just one field with the type, that field if (found == null) { for (Field f : fields) { if (f.getType() == type) { // If more than one, can't choose if (found != null) return null; found

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>+SAMPLE_SPEC_VALUE_TN_ID4+"]\n" +" }" +"}" ; /* /********************************************************** /* Helper classes (beans) /********************************************************** */ /** * Sample class from Jackson tutorial ("JacksonInFiveMinutes") */ protected static class FiveMinuteUser { public enum Gender { MALE, FEMALE }; public static class Name { private String _first, _last; public Name() { } public Name(String f, String l) { _first = f; _last = l; } public String getFirst() { return _first; } public String getLast() { return _last; } public void setFirst(String s) { _first = s; } public void setLast(String s) { _last = s; } @Override public boolean equals(Object o) { if (o == this) return true; if (o == null || o.getClass() != getClass()) return false; Name other = (Name) o; return _first.equals(other._first) && _last.equals(other._last); } } private Gender _gender; private Name _name; private boolean _isVerified; private byte[] _userImage; public FiveMinuteUser() { } public FiveMinuteUser(String first, String last, boolean verified, Gender g, byte[] data) { _name = new Name(first, last); _isVerified = verified; _gender = g; _userImage = data; } public Name getName() { return _name; } public boolean isVerified() { return _isVerified; } public Gender getGender() { return _gender; } public byte[] getUserImage() { return _userImage; } public void setName(Name n) { _name = n; } public void setVerified(boolean b) { _isVerified = b; } public void setGender(Gender g) { _gender = g; } public void setUserImage(byte[] b) { _userImage = b; } @Override public boolean equals(Object o) { if (o == this) return true; if (o == null || o.getClass() != getClass()) return

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>, String encoding) throws IOException, JsonParseException { /* 23-Apr-2008, tatus: UTF-32 is not supported by JDK, have to * use our own codec too (which is not optimal since there's * a chance both encoder and decoder might have bugs, but ones * that cancel each other out or such) */ byte[] data; if (encoding.equalsIgnoreCase("UTF-32")) { data = encodeInUTF32BE(input); } else { data = input.getBytes(encoding); } InputStream is = new ByteArrayInputStream(data); return f.createParser(is); } /* /********************************************************** /* Additional assertion methods /********************************************************** */ protected void assertToken(JsonToken expToken, JsonToken actToken) { if (actToken != expToken) { fail("Expected token "+expToken+", current token "+actToken); } } protected void assertToken(JsonToken expToken, JsonParser jp) { assertToken(expToken, jp.getCurrentToken()); } protected void assertType(Object ob, Class<?> expType) { if (ob == null) { fail("Expected an object of type "+expType.getName()+", got null"); } Class<?> cls = ob.getClass(); if (!expType.isAssignableFrom(cls)) { fail("Expected type "+expType.getName()+", got "+cls.getName()); } } protected void assertValidLocation(JsonLocation location) { assertNotNull("Should have non-null location", location); assertTrue("Should have positive line number", location.getLineNr() > 0); } protected void verifyException(Throwable e, String... matches) { String msg = e.getMessage(); String lmsg = (msg == null) ? "" : msg.toLowerCase(); for (String match : matches) { String lmatch = match.toLowerCase(); if (lmsg.indexOf(lmatch) >= 0) { return; } } fail("Expected an exception with one of substrings ("+Arrays.asList(matches)+"): got one with message \""+msg+"\""); } /** * Method that gets textual contents of the current token using * available methods, and ensures results

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.impl; import java.util.Map; import com.fasterxml.jackson.databind.JsonSerializer; import com.fasterxml.jackson.databind.ser.SerializerCache.TypeKey; /** * Specialized read-only map used for storing and accessing serializers by type. * Used for per-{@link com.fasterxml.jackson.databind.ObjectMapper} sharing * of resolved serializers; in addition, a per-call non-shared read/write * map may be needed, which will (after call) get merged to create a new * shared map of this type. */ public class JsonSerializerMap { private final Bucket[] _buckets; private final int _size; public JsonSerializerMap(Map<TypeKey,JsonSerializer<Object>> serializers) { int size = findSize(serializers.size()); _size = size; int hashMask = (size-1); Bucket[] buckets = new Bucket[size]; for (Map.Entry<TypeKey,JsonSerializer<Object>> entry : serializers.entrySet()) { TypeKey key = entry.getKey(); int index = key.hashCode() & hashMask; buckets[index] = new Bucket(buckets[index], key, entry.getValue()); } _buckets = buckets; } private final static int findSize(int size) { // For small enough results (64 or less), we'll require <= 50% fill rate; otherwise 80% int needed = (size <= 64) ? (size + size) : (size + (size >> 2)); int result = 8; while (result < needed) { result += result; } return result; } /* /********************************************************** /* Public API /********************************************************** */ public int size() { return _size; } public JsonSerializer<Object> find(TypeKey key) { int index = key.hashCode() & (_buckets.length-1); Bucket bucket = _buckets[index]; /* Ok let's actually try unrolling loop slightly as this shows up in profiler; * and also because in vast majority of cases first entry is either null * or matches. */ if (bucket == null) { return null; } if (key.

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>link JsonGenerator} * constructed for serializing values. * * @since 2.5 */ protected final GeneratorSettings _generatorSettings; /** * We may pre-fetch serializer if {@link #_rootType} * is known, and if so, reuse it afterwards. * This allows avoiding further serializer lookups and increases * performance a bit on cases where readers are reused. * * @since 2.5 */ protected final Prefetch _prefetch; /* /********************************************************** /* Life-cycle, constructors /********************************************************** */ /** * Constructor used by {@link ObjectMapper} for initial instantiation */ protected ObjectWriter(ObjectMapper mapper, SerializationConfig config, JavaType rootType, PrettyPrinter pp) { _config = config; _serializerProvider = mapper._serializerProvider; _serializerFactory = mapper._serializerFactory; _generatorFactory = mapper._jsonFactory; _generatorSettings = (pp == null) ? GeneratorSettings.empty : new GeneratorSettings(pp, null, null, null); // 29-Apr-2014, tatu: There is no "untyped serializer", so: if (rootType == null || rootType.hasRawClass(Object.class)) { _prefetch = Prefetch.empty; } else { rootType = rootType.withStaticTyping(); _prefetch = _prefetchRootSerializer(config, rootType); } } /** * Alternative constructor for initial instantiation by {@link ObjectMapper} */ protected ObjectWriter(ObjectMapper mapper, SerializationConfig config) { _config = config; _serializerProvider = mapper._serializerProvider; _serializerFactory = mapper._serializerFactory; _generatorFactory = mapper._jsonFactory; _prefetch = Prefetch.empty; _generatorSettings = GeneratorSettings.empty; } /** * Alternative constructor for initial instantiation by {@link ObjectMapper} */ protected ObjectWriter(ObjectMapper mapper, SerializationConfig config, FormatSchema s) { _config = config; _serializerProvider = mapper._serializerProvider; _serializerFactory = mapper._serializerFactory; _generatorFactory = mapper._jsonFactory; _prefetch = Prefetch.empty; _generatorSettings = (s == null) ? GeneratorSettings.empty : new GeneratorSettings

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> /** * @deprecated Since 2.5 use {@link #with(FormatSchema)} instead */ @Deprecated public ObjectWriter withSchema(FormatSchema schema) { return with(schema); } /** * Method that will construct a new instance that uses specific type * as the root type for serialization, instead of runtime dynamic * type of the root object itself. *<p> * Note that method does NOT change state of this reader, but * rather construct and returns a newly configured instance. * * @since 2.5 */ public ObjectWriter forType(JavaType rootType) { Prefetch pf; if (rootType == null || rootType.hasRawClass(Object.class)) { pf = Prefetch.empty; } else { // 15-Mar-2013, tatu: Important! Indicate that static typing is needed: rootType = rootType.withStaticTyping(); pf = _prefetchRootSerializer(_config, rootType); } return (pf == _prefetch) ? this : _new(_generatorSettings, pf); } /** * Method that will construct a new instance that uses specific type * as the root type for serialization, instead of runtime dynamic * type of the root object itself. * * @since 2.5 */ public ObjectWriter forType(Class<?> rootType) { if (rootType == Object.class) { return forType((JavaType) null); } return forType(_config.constructType(rootType)); } public ObjectWriter forType(TypeReference<?> rootType) { return forType(_config.getTypeFactory().constructType(rootType.getType())); } /** * @deprecated since 2.5 Use {@link #forType(JavaType)} instead */ @Deprecated // since 2.5 public ObjectWriter withType(JavaType rootType) { return forType(rootType); } /** * @deprecated since 2.5 Use {@link #forType(Class)} instead */ @Deprecated // since 2.5 public ObjectWriter withType(Class<?> rootType) { return forType(rootType); } /** * @deprecated since 2.5 Use {@link #

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>) { return _serializerProvider(_config).hasSerializerFor(type, cause); } /* /********************************************************** /* Overridable helper methods /********************************************************** */ /** * Overridable helper method used for constructing * {@link SerializerProvider} to use for serialization. */ protected DefaultSerializerProvider _serializerProvider(SerializationConfig config) { return _serializerProvider.createInstance(config, _serializerFactory); } /* /********************************************************** /* Internal methods /********************************************************** */ /** * @since 2.2 */ protected void _verifySchemaType(FormatSchema schema) { if (schema != null) { if (!_generatorFactory.canUseSchema(schema)) { throw new IllegalArgumentException("Can not use FormatSchema of type "+schema.getClass().getName() +" for format "+_generatorFactory.getFormatName()); } } } /** * Method called to configure the generator as necessary and then * call write functionality */ protected final void _configAndWriteValue(JsonGenerator gen, Object value) throws IOException { _configureGenerator(gen); // [JACKSON-282]: consider Closeable if (_config.isEnabled(SerializationFeature.CLOSE_CLOSEABLE) && (value instanceof Closeable)) { _writeCloseable(gen, value, _config); return; } boolean closed = false; try { if (_prefetch.valueSerializer != null) { _serializerProvider(_config).serializeValue(gen, value, _prefetch.rootType, _prefetch.valueSerializer); } else if (_prefetch.typeSerializer != null) { _serializerProvider(_config).serializePolymorphic(gen, value, _prefetch.typeSerializer); } else { _serializerProvider(_config).serializeValue(gen, value); } closed = true; gen.close(); } finally { /* won't try to close twice; also, must catch exception (so it * will not mask exception that is pending) */ if (!closed) { /* 04-Mar-2014, tatu: But! Let's try to prevent auto-closing of * structures, which typically causes more damage. */ gen.disable(JsonGenerator.Feature.AUTO_CLOSE_JSON_CONTENT);

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> unwrapped values (via @JsonUnwrapped) SettableBeanProperty u = _resolveUnwrappedProperty(ctxt, prop); if (u != null) { prop = u; if (unwrapped == null) { unwrapped = new UnwrappedPropertyHandler(); } unwrapped.addProperty(prop); /* 12-Dec-2014, tatu: As per [databind#647], we will have problems if * the original property is left in place. So let's remove it now. */ _beanProperties.remove(prop); continue; } // [JACKSON-594]: non-static inner classes too: prop = _resolveInnerClassValuedProperty(ctxt, prop); if (prop != origProp) { _beanProperties.replace(prop); } /* one more thing: if this property uses "external property" type inclusion * (see [JACKSON-453]), it needs different handling altogether */ if (prop.hasValueTypeDeserializer()) { TypeDeserializer typeDeser = prop.getValueTypeDeserializer(); if (typeDeser.getTypeInclusion() == JsonTypeInfo.As.EXTERNAL_PROPERTY) { if (extTypes == null) { extTypes = new ExternalTypeHandler.Builder(); } extTypes.addExternal(prop, typeDeser); // In fact, remove from list of known properties to simplify later handling _beanProperties.remove(prop); continue; } } } // "any setter" may also need to be resolved now if (_anySetter != null && !_anySetter.hasValueDeserializer()) { _anySetter = _anySetter.withValueDeserializer(findDeserializer(ctxt, _anySetter.getType(), _anySetter.getProperty())); } // as well as delegate-based constructor: if (_valueInstantiator.canCreateUsingDelegate()) { JavaType delegateType = _valueInstantiator.getDelegateType(ctxt.getConfig()); if (delegateType == null) { throw new IllegalArgumentException("Invalid delegate-creator definition for "+_beanType +": value instantiator ("+_valueInstantiator.getClass().getName() +") returned true for 'canCreateUsingDelegate()', but null for 'getDelegateType()'"); } AnnotatedWithParams

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> is done in resolve(), we only get * access to referring property's annotations here; and this is needed * to support per-property ObjectIds. * We will also consider Shape transformations (read from Array) at this * point, since it may come from either Class definition or property. */ @Override public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException { ObjectIdReader oir = _objectIdReader; // First: may have an override for Object Id: final AnnotationIntrospector intr = ctxt.getAnnotationIntrospector(); final AnnotatedMember accessor = (property == null || intr == null) ? null : property.getMember(); if (accessor != null && intr != null) { ObjectIdInfo objectIdInfo = intr.findObjectIdInfo(accessor); if (objectIdInfo != null) { // some code duplication here as well (from BeanDeserializerFactory) // 2.1: allow modifications by "id ref" annotations as well: objectIdInfo = intr.findObjectReferenceInfo(accessor, objectIdInfo); Class<?> implClass = objectIdInfo.getGeneratorType(); // Property-based generator is trickier JavaType idType; SettableBeanProperty idProp; ObjectIdGenerator<?> idGen; ObjectIdResolver resolver = ctxt.objectIdResolverInstance(accessor, objectIdInfo); if (implClass == ObjectIdGenerators.PropertyGenerator.class) { PropertyName propName = objectIdInfo.getPropertyName(); idProp = findProperty(propName); if (idProp == null) { throw new IllegalArgumentException("Invalid Object Id definition for " +handledType().getName()+": can not find property with name '"+propName+"'"); } idType = idProp.getType(); idGen = new PropertyBasedObjectIdGenerator(objectIdInfo.getScope()); } else { // other types need to be simpler JavaType type = ctxt.constructType(implClass); idType = ctxt.getTypeFactory().findTypeParameters(type, ObjectIdGenerator.class)[0]; idProp = null; idGen = ctxt.objectIdGeneratorInstance(accessor, objectIdInfo); } JsonDeserializer<?> deser = ctxt.findRootValueDeserializer(idType); oir = ObjectIdReader.construct(idType, objectIdInfo.getPropertyName(),

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>Token(); if (t != null) { // Most commonly, a scalar (int id, uuid String, ...) if (t.isScalarValue()) { return deserializeFromObjectId(p, ctxt); } // but, with 2.5+, a simple Object-wrapped value also legal: if (t == JsonToken.START_OBJECT) { t = p.nextToken(); } if (t == JsonToken.FIELD_NAME && _objectIdReader.maySerializeAsObject() && _objectIdReader.isValidReferencePropertyName(p.getCurrentName(), p)) { return deserializeFromObjectId(p, ctxt); } } } // In future could check current token... for now this should be enough: return typeDeserializer.deserializeTypedFromObject(p, ctxt); } /** * Offlined method called to handle "native" Object Id that has been read * and known to be associated with given deserialized POJO. * * @since 2.3 */ protected Object _handleTypedObjectId(JsonParser jp, DeserializationContext ctxt, Object pojo, Object rawId) throws IOException { /* 07-Aug-2013, tatu: One more challenge: type of id may not be type * of property we are expecting later on; specifically, numeric ids * vs Strings. */ JsonDeserializer<Object> idDeser = _objectIdReader.getDeserializer(); final Object id; // Ok, this is bit ridiculous; let's see if conversion is needed: if (idDeser.handledType() == rawId.getClass()) { // nope: already same type id = rawId; } else { id = _convertObjectId(jp, ctxt, rawId, idDeser); } ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver); roid.bindItem(pojo); // also: may need to set a property value as well SettableBeanProperty idProp = _objectIdReader.idProperty; if (idProp != null) { return idProp.setAndReturn(pojo, id); } return pojo; } /** * Helper method we need to do necessary conversion from whatever native object id *

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> all properties are passed * in buffer */ @SuppressWarnings("resource") protected Object handlePolymorphic(JsonParser jp, DeserializationContext ctxt, Object bean, TokenBuffer unknownTokens) throws IOException, JsonProcessingException { // First things first: maybe there is a more specific deserializer available? JsonDeserializer<Object> subDeser = _findSubclassDeserializer(ctxt, bean, unknownTokens); if (subDeser != null) { if (unknownTokens != null) { // need to add END_OBJECT marker first unknownTokens.writeEndObject(); JsonParser p2 = unknownTokens.asParser(); p2.nextToken(); // to get to first data field bean = subDeser.deserialize(p2, ctxt, bean); } // Original parser may also have some leftovers if (jp != null) { bean = subDeser.deserialize(jp, ctxt, bean); } return bean; } // nope; need to use this deserializer. Unknowns we've seen so far? if (unknownTokens != null) { bean = handleUnknownProperties(ctxt, bean, unknownTokens); } // and/or things left to process via main parser? if (jp != null) { bean = deserialize(jp, ctxt, bean); } return bean; } /** * Helper method called to (try to) locate deserializer for given sub-type of * type that this deserializer handles. */ protected JsonDeserializer<Object> _findSubclassDeserializer(DeserializationContext ctxt, Object bean, TokenBuffer unknownTokens) throws IOException, JsonProcessingException { JsonDeserializer<Object> subDeser; // First: maybe we have already created sub-type deserializer? synchronized (this) { subDeser = (_subDeserializers == null) ? null : _subDeserializers.get(new ClassKey(bean.getClass())); } if (subDeser != null) { return subDeser; } // If not, maybe we can locate one. First, need provider JavaType type = ctxt.constructType(bean.getClass()); /* 30-Jan-2012, tatu: Ideally we would be passing referring * property; which in theory we could keep track of

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> via * ResolvableDeserializer (if we absolutely must...). * But for now, let's not bother. */ // subDeser = ctxt.findValueDeserializer(type, _property); subDeser = ctxt.findRootValueDeserializer(type); // Also, need to cache it if (subDeser != null) { synchronized (this) { if (_subDeserializers == null) { _subDeserializers = new HashMap<ClassKey,JsonDeserializer<Object>>();; } _subDeserializers.put(new ClassKey(bean.getClass()), subDeser); } } return subDeser; } /* /********************************************************** /* Helper methods for error reporting /********************************************************** */ /** * Method that will modify caught exception (passed in as argument) * as necessary to include reference information, and to ensure it * is a subtype of {@link IOException}, or an unchecked exception. *<p> * Rules for wrapping and unwrapping are bit complicated; essentially: *<ul> * <li>Errors are to be passed as is (if uncovered via unwrapping) * <li>"Plain" IOExceptions (ones that are not of type * {@link JsonMappingException} are to be passed as is *</ul> */ public void wrapAndThrow(Throwable t, Object bean, String fieldName, DeserializationContext ctxt) throws IOException { // [JACKSON-55] Need to add reference information throw JsonMappingException.wrapWithPath(throwOrReturnThrowable(t, ctxt), bean, fieldName); } @Deprecated // since 2.4, not used by core Jackson; only relevant for arrays/Collections public void wrapAndThrow(Throwable t, Object bean, int index, DeserializationContext ctxt) throws IOException { // [JACKSON-55] Need to add reference information throw JsonMappingException.wrapWithPath(throwOrReturnThrowable(t, ctxt), bean, index); } private Throwable throwOrReturnThrowable(Throwable t, DeserializationContext ctxt) throws IOException { /* 05-Mar-2009, tatu: But one nasty edge is when we get * StackOverflow: usually due to infinite loop. But that * often gets

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> * for structured types, or serializers for root values) * to handle details of resolving * {@link ContextualDeserializer} with given property context. * Given that these serializers are not directly related to given property * (or, in case of root value property, to any property), annotations * accessible may or may not be relevant. * * @param property Property for which serializer is used, if any; null * when deserializing root values * * @since 2.3 */ public JsonSerializer<?> handleSecondaryContextualization(JsonSerializer<?> ser, BeanProperty property) throws JsonMappingException { if (ser != null) { if (ser instanceof ContextualSerializer) { ser = ((ContextualSerializer) ser).createContextual(this, property); } } return ser; } /* /******************************************************** /* Convenience methods for serializing using default methods /******************************************************** */ /** * Convenience method that will serialize given value (which can be * null) using standard serializer locating functionality. It can * be called for all values including field and Map values, but usually * field values are best handled calling * {@link #defaultSerializeField} instead. */ public final void defaultSerializeValue(Object value, JsonGenerator jgen) throws IOException { if (value == null) { if (_stdNullValueSerializer) { // minor perf optimization jgen.writeNull(); } else { _nullValueSerializer.serialize(null, jgen, this); } } else { Class<?> cls = value.getClass(); findTypedValueSerializer(cls, true, null).serialize(value, jgen, this); } } /** * Convenience method that will serialize given field with specified * value. Value may be null. Serializer is done using the usual * null) using standard serializer locating functionality. */ public final void defaultSerializeField(String fieldName, Object value, JsonGenerator jgen) throws IOException { jgen.writeFieldName(fieldName); if (value == null) { /* Note: can't easily check for suppression at this point * any more; caller must check it. */ if (_stdNullValueSerializer) { // minor perf optimization jgen.writeNull(); } else { _nullValueSerializer.serialize(

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>null, jgen, this); } } else { Class<?> cls = value.getClass(); findTypedValueSerializer(cls, true, null).serialize(value, jgen, this); } } /** * Method that will handle serialization of Date(-like) values, using * {@link SerializationConfig} settings to determine expected serialization * behavior. * Note: date here means "full" date, that is, date AND time, as per * Java convention (and not date-only values like in SQL) */ public final void defaultSerializeDateValue(long timestamp, JsonGenerator jgen) throws IOException { // [JACKSON-87]: Support both numeric timestamps and textual if (isEnabled(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)) { jgen.writeNumber(timestamp); } else { jgen.writeString(_dateFormat().format(new Date(timestamp))); } } /** * Method that will handle serialization of Date(-like) values, using * {@link SerializationConfig} settings to determine expected serialization * behavior. * Note: date here means "full" date, that is, date AND time, as per * Java convention (and not date-only values like in SQL) */ public final void defaultSerializeDateValue(Date date, JsonGenerator jgen) throws IOException { // [JACKSON-87]: Support both numeric timestamps and textual if (isEnabled(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)) { jgen.writeNumber(date.getTime()); } else { jgen.writeString(_dateFormat().format(date)); } } /** * Method that will handle serialization of Dates used as {@link java.util.Map} keys, * based on {@link SerializationFeature#WRITE_DATE_KEYS_AS_TIMESTAMPS} * value (and if using textual representation, configured date format) */ public void defaultSerializeDateKey(long timestamp, JsonGenerator jgen) throws IOException { if (isEnabled(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS)) { jgen.writeFieldName(String.valueOf(timestamp)); } else { jgen.writeFieldName(_dateFormat().format(new Date(timestamp))); }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> } /** * Method that will handle serialization of Dates used as {@link java.util.Map} keys, * based on {@link SerializationFeature#WRITE_DATE_KEYS_AS_TIMESTAMPS} * value (and if using textual representation, configured date format) */ public void defaultSerializeDateKey(Date date, JsonGenerator jgen) throws IOException { if (isEnabled(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS)) { jgen.writeFieldName(String.valueOf(date.getTime())); } else { jgen.writeFieldName(_dateFormat().format(date)); } } public final void defaultSerializeNull(JsonGenerator jgen) throws IOException { if (_stdNullValueSerializer) { // minor perf optimization jgen.writeNull(); } else { _nullValueSerializer.serialize(null, jgen, this); } } /* /******************************************************** /* Error reporting /******************************************************** */ /** * @since 2.6 */ public JsonMappingException mappingException(String message, Object... args) { if (args != null && args.length > 0) { message = String.format(message, args); } return new JsonMappingException(message); } /* /******************************************************** /* Helper methods /******************************************************** */ protected void _reportIncompatibleRootType(Object value, JavaType rootType) throws IOException, JsonProcessingException { /* 07-Jan-2010, tatu: As per [JACKSON-456] better handle distinction between wrapper types, * primitives */ if (rootType.isPrimitive()) { Class<?> wrapperType = ClassUtil.wrapperType(rootType.getRawClass()); // If it's just difference between wrapper, primitive, let it slide if (wrapperType.isAssignableFrom(value.getClass())) { return; } } throw new JsonMappingException("Incompatible types: declared root type ("+rootType+") vs " +value.getClass().getName()); } /** * Method that will try to find a serializer, either from cache * or by constructing one; but will not return an "unknown" serializer * if this can not be done but rather returns null. * * @return Serializer if one

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std; import java.io.IOException; import java.text.DateFormat; import java.util.Calendar; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.SerializerProvider; import com.fasterxml.jackson.databind.annotation.JacksonStdImpl; /** * Standard serializer for {@link java.util.Calendar}. * As with other time/date types, is configurable to produce timestamps * (standard Java 64-bit timestamp) or textual formats (usually ISO-8601). */ @JacksonStdImpl @SuppressWarnings("serial") public class CalendarSerializer extends DateTimeSerializerBase<Calendar> { public static final CalendarSerializer instance = new CalendarSerializer(); public CalendarSerializer() { this(null, null); } public CalendarSerializer(Boolean useTimestamp, DateFormat customFormat) { super(Calendar.class, useTimestamp, customFormat); } @Override public CalendarSerializer withFormat(Boolean timestamp, DateFormat customFormat) { return new CalendarSerializer(timestamp, customFormat); } @Override protected long _timestamp(Calendar value) { return (value == null) ? 0L : value.getTimeInMillis(); } @Override public void serialize(Calendar value, JsonGenerator jgen, SerializerProvider provider) throws IOException { if (_asTimestamp(provider)) { jgen.writeNumber(_timestamp(value)); } else if (_customFormat != null) { // 21-Feb-2011, tatu: not optimal, but better than alternatives: synchronized (_customFormat) { // _customformat cannot parse Calendar, so Date should be passed jgen.writeString(_customFormat.format(value.getTime())); } } else { provider.defaultSerializeDateValue(value.getTime(), jgen); } } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.type; import com.fasterxml.jackson.databind.JavaType; /** * Type that represents Java Collection types (Lists, Sets). */ public final class CollectionType extends CollectionLikeType { private static final long serialVersionUID = -7834910259750909424L; /* /********************************************************** /* Life-cycle /********************************************************** */ private CollectionType(Class<?> collT, JavaType elemT, Object valueHandler, Object typeHandler, boolean asStatic) { super(collT, elemT, valueHandler, typeHandler, asStatic); } @Override protected JavaType _narrow(Class<?> subclass) { return new CollectionType(subclass, _elementType, null, null, _asStatic); } @Override public JavaType narrowContentsBy(Class<?> contentClass) { // Can do a quick check first: if (contentClass == _elementType.getRawClass()) { return this; } return new CollectionType(_class, _elementType.narrowBy(contentClass), _valueHandler, _typeHandler, _asStatic); } @Override public JavaType widenContentsBy(Class<?> contentClass) { // Can do a quick check first: if (contentClass == _elementType.getRawClass()) { return this; } return new CollectionType(_class, _elementType.widenBy(contentClass), _valueHandler, _typeHandler, _asStatic); } public static CollectionType construct(Class<?> rawType, JavaType elemT) { // nominally component types will be just Object.class return new CollectionType(rawType, elemT, null, null, false); } // Since 1.7: @Override public CollectionType withTypeHandler(Object h) { return new CollectionType(_class, _elementType, _valueHandler, h, _asStatic); } // Since 1.7: @Override public CollectionType withContentTypeHandler(Object h) { return new CollectionType(_class, _elementType.withTypeHandler(h), _valueHandler, _typeHandler, _asStatic); } @Override public CollectionType withValueHandler

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>(Object h) { return new CollectionType(_class, _elementType, h, _typeHandler, _asStatic); } @Override public CollectionType withContentValueHandler(Object h) { return new CollectionType(_class, _elementType.withValueHandler(h), _valueHandler, _typeHandler, _asStatic); } @Override public CollectionType withStaticTyping() { if (_asStatic) { return this; } return new CollectionType(_class, _elementType.withStaticTyping(), _valueHandler, _typeHandler, true); } /* /********************************************************** /* Overridden accessors /********************************************************** */ @Override public Class<?> getParameterSource() { return java.util.Collection.class; } /* /********************************************************** /* Standard methods /********************************************************** */ @Override public String toString() { return "[collection type; class "+_class.getName()+", contains "+_elementType+"]"; } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.util.Converter; /** * Annotation used for configuring serialization aspects, by attaching * to "getter" methods or fields, or to value classes. * When annotating value classes, configuration is used for instances * of the value class but can be overridden by more specific annotations * (ones that attach to methods or fields). *<p> * An example annotation would be: *<pre> * &#64;JsonSerialize(using=MySerializer.class, * as=MySubClass.class, * typing=JsonSerialize.Typing.STATIC * ) *</pre> * (which would be redundant, since some properties block others: * specifically, 'using' has precedence over 'as', which has precedence * over 'typing' setting) */ @Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD, ElementType.FIELD, ElementType.TYPE, ElementType.PARAMETER}) @Retention(RetentionPolicy.RUNTIME) @com.fasterxml.jackson.annotation.JacksonAnnotation public @interface JsonSerialize { // // // Annotations for explicitly specifying deserializer /** * Serializer class to use for * serializing associated value. Depending on what is annotated, * value is either an instance of annotated class (used globablly * anywhere where class serializer is needed); or only used for * serializing property access via a getter method. */ public Class<? extends JsonSerializer<?>> using() default JsonSerializer.None.class; /** * Serializer class to use for serializing contents (elements * of a Collection/array, values of Maps) of annotated property. * Can only be used on properties (methods, fields, constructors), * and not value classes themselves (as they are typically generic) */ public Class<? extends JsonSerializer<?>> contentUsing() default JsonSerializer.None.class; /** * Serializer class to use for serializing Map keys * of annotated property. * Can only be used on properties (methods, fields, constructors),

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> * and not value classes themselves. */ public Class<? extends JsonSerializer<?>> keyUsing() default JsonSerializer.None.class; /** * Serializer class to use for serializing nulls for properties that * are annotated, instead of the * default null serializer. * Note that using this property when annotation types (classes) has * no effect currently (it is possible this could be improved in future). * * @since 2.3 */ public Class<? extends JsonSerializer<?>> nullsUsing() default JsonSerializer.None.class; // // // Annotations for type handling, explicit declaration // // // (type used for choosing deserializer, if not explicitly // // // specified) /** * Supertype (of declared type, which itself is supertype of runtime type) * to use as type when locating serializer to use. *<p> * Bogus type {@link Void} can be used to indicate that declared * type is used as is (i.e. this annotation property has no setting); * this since annotation properties are not allowed to have null value. *<p> * Note: if {@link #using} is also used it has precedence * (since it directly specifies * serializer, whereas this would only be used to locate the * serializer) * and value of this annotation property is ignored. */ public Class<?> as() default Void.class; /** * Concrete type to serialize keys of {@link java.util.Map} as, * instead of type otherwise declared. * Must be a supertype of declared type; otherwise an exception may be * thrown by serializer. */ public Class<?> keyAs() default Void.class; /** * Concrete type to serialize content value (elements * of a Collection/array, values of Maps) as, * instead of type otherwise declared. * Must be a supertype of declared type; otherwise an exception may be * thrown by serializer. */ public Class<?> contentAs() default Void.class; /** * Whether type detection used is dynamic or static: that is, * whether actual runtime type is used (dynamic), or just the * declared type (static). *<p> * Note that Jackson 2.3 changed default to <code>DEFAULT_TYPING</code>,

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> * which is roughly same as saying "whatever". * This is important as it allows avoiding accidental overrides * at property level. */ public Typing typing() default Typing.DEFAULT_TYPING; // // // Annotations for specifying intermediate Converters (2.2+) /** * Which helper object is to be used to convert type into something * that Jackson knows how to serialize; either because base type * can not be serialized easily, or just to alter serialization. * * @since 2.2 */ public Class<? extends Converter<?,?>> converter() default Converter.None.class; /** * Similar to {@link #converter}, but used for values of structures types * (List, arrays, Maps). * Note that this property does NOT have effect when used as Class annotation; * it can only be used as property annotation: this because association between * container and value types is loose and as such converters seldom make sense * for such usage. * * @since 2.2 */ public Class<? extends Converter<?,?>> contentConverter() default Converter.None.class; // // // Annotation(s) for inclusion criteria /** * Which properties of annotated Bean are * to be included in serialization (has no effect on other types * like enums, primitives or collections). * Choices are "all", "properties that have value other than null" * and "properties that have non-default value" (i.e. default value * being property setting for a Bean constructed with default no-arg * constructor, often null). *<p> * Note that Jackson 2.3 changed default to <code>DEFAULT_INCLUSION</code>, * which is roughly same as saying "whatever". This is important because * it allows hierarchic default values to be used. * * @deprecated As of Jackson 2.0, this annotation has been replaced * by {@link com.fasterxml.jackson.annotation.JsonInclude} */ @Deprecated public Inclusion include() default Inclusion.DEFAULT_INCLUSION; /* /********************************************************** /* Value enumerations needed /********************************************************** */ /** * Enumeration used with {@link JsonSerialize#include} property * to define which properties * of

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>standardStringKey; } protected MapDeserializer(MapDeserializer src, KeyDeserializer keyDeser, JsonDeserializer<Object> valueDeser, TypeDeserializer valueTypeDeser, HashSet<String> ignorable) { super(src._mapType); _mapType = src._mapType; _keyDeserializer = keyDeser; _valueDeserializer = valueDeser; _valueTypeDeserializer = valueTypeDeser; _valueInstantiator = src._valueInstantiator; _propertyBasedCreator = src._propertyBasedCreator; _delegateDeserializer = src._delegateDeserializer; _hasDefaultCreator = src._hasDefaultCreator; _ignorableProperties = ignorable; _standardStringKey = _isStdKeyDeser(_mapType, keyDeser); } /** * Fluent factory method used to create a copy with slightly * different settings. When sub-classing, MUST be overridden. */ @SuppressWarnings("unchecked") protected MapDeserializer withResolved(KeyDeserializer keyDeser, TypeDeserializer valueTypeDeser, JsonDeserializer<?> valueDeser, HashSet<String> ignorable) { if ((_keyDeserializer == keyDeser) && (_valueDeserializer == valueDeser) && (_valueTypeDeserializer == valueTypeDeser) && (_ignorableProperties == ignorable)) { return this; } return new MapDeserializer(this, keyDeser, (JsonDeserializer<Object>) valueDeser, valueTypeDeser, ignorable); } /** * Helper method used to check whether we can just use the default key * deserialization, where JSON String becomes Java String. */ protected final boolean _isStdKeyDeser(JavaType mapType, KeyDeserializer keyDeser) { if (keyDeser == null) { return true; } JavaType keyType = mapType.getKeyType(); if (keyType == null) { // assumed to be Object return true; } Class<?> rawKeyType = keyType.getRawClass(); return ((rawKeyType == String.class || rawKeyType == Object.class) && isDefaultKeyDeserializer(keyDeser)); } public void setIgnorableProperties(String[] ignorable) { _ignorableProperties = (ignorable == null || ignorable.length == 0) ? null :

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> ArrayBuilders.arrayToSet(ignorable); } /* /********************************************************** /* Validation, post-processing (ResolvableDeserializer) /********************************************************** */ @Override public void resolve(DeserializationContext ctxt) throws JsonMappingException { // May need to resolve types for delegate- and/or property-based creators: if (_valueInstantiator.canCreateUsingDelegate()) { JavaType delegateType = _valueInstantiator.getDelegateType(ctxt.getConfig()); if (delegateType == null) { throw new IllegalArgumentException("Invalid delegate-creator definition for "+_mapType +": value instantiator ("+_valueInstantiator.getClass().getName() +") returned true for 'canCreateUsingDelegate()', but null for 'getDelegateType()'"); } /* Theoretically should be able to get CreatorProperty for delegate * parameter to pass; but things get tricky because DelegateCreator * may contain injectable values. So, for now, let's pass nothing. */ _delegateDeserializer = findDeserializer(ctxt, delegateType, null); } if (_valueInstantiator.canCreateFromObjectWith()) { SettableBeanProperty[] creatorProps = _valueInstantiator.getFromObjectArguments(ctxt.getConfig()); _propertyBasedCreator = PropertyBasedCreator.construct(ctxt, _valueInstantiator, creatorProps); } _standardStringKey = _isStdKeyDeser(_mapType, _keyDeserializer); } /** * Method called to finalize setup of this deserializer, * when it is known for which property deserializer is needed for. */ @Override public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException { KeyDeserializer kd = _keyDeserializer; if (kd == null) { kd = ctxt.findKeyDeserializer(_mapType.getKeyType(), property); } else { if (kd instanceof ContextualKeyDeserializer) { kd = ((ContextualKeyDeserializer) kd).createContextual(ctxt, property); } } JsonDeserializer<?> vd = _valueDeserializer; // #125: May have a content converter if (property != null) { vd = findConvertingContentDeserializer(ctxt, property, vd); } final JavaType vt = _mapType.getContentType();

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.impl; import java.io.IOException; import java.util.*; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.annotation.JacksonStdImpl; import com.fasterxml.jackson.databind.introspect.AnnotatedMember; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonArrayFormatVisitor; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatTypes; import com.fasterxml.jackson.databind.jsontype.TypeSerializer; import com.fasterxml.jackson.databind.ser.ContextualSerializer; import com.fasterxml.jackson.databind.ser.std.StaticListSerializerBase; /** * Efficient implement for serializing {@link List}s that contains Strings and are random-accessible. * The only complexity is due to possibility that serializer for {@link String} * may be overridde; because of this, logic is needed to ensure that the default * serializer is in use to use fastest mode, or if not, to defer to custom * String serializer. */ @JacksonStdImpl public final class IndexedStringListSerializer extends StaticListSerializerBase<List<String>> implements ContextualSerializer { private static final long serialVersionUID = 1L; public final static IndexedStringListSerializer instance = new IndexedStringListSerializer(); protected final JsonSerializer<String> _serializer; /* /********************************************************** /* Life-cycle /********************************************************** */ protected IndexedStringListSerializer() { this(null); } @SuppressWarnings("unchecked") public IndexedStringListSerializer(JsonSerializer<?> ser) { super(List.class); _serializer = (JsonSerializer<String>) ser; } @Override protected JsonNode contentSchema() { return createSchemaNode("string", true); } @Override protected void acceptContentVisitor(JsonArrayFormatVisitor visitor) throws JsonMappingException { visitor.itemsFormat(JsonFormatTypes.STRING); } /* /********************************************************** /* Post-processing /********************************************************** */ @Override public JsonSerializer<?> createContextual(SerializerProvider provider, BeanProperty property) throws JsonMappingException { /* 29-Sep-2012, tatu: Actually,

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> we need to do much more contextual * checking here since we finally know for sure the property, * and it may have overrides */ JsonSerializer<?> ser = null; // First: if we have a property, may have property-annotation overrides if (property != null) { AnnotatedMember m = property.getMember(); if (m != null) { Object serDef = provider.getAnnotationIntrospector().findContentSerializer(m); if (serDef != null) { ser = provider.serializerInstance(m, serDef); } } } if (ser == null) { ser = _serializer; } // #124: May have a content converter ser = findConvertingContentSerializer(provider, property, ser); if (ser == null) { ser = provider.findValueSerializer(String.class, property); } else { ser = provider.handleSecondaryContextualization(ser, property); } // Optimization: default serializer just writes String, so we can avoid a call: if (isDefaultSerializer(ser)) { ser = null; } // note: will never have TypeSerializer, because Strings are "natural" type if (ser == _serializer) { return this; } return new IndexedStringListSerializer(ser); } /* /********************************************************** /* Actual serialization /********************************************************** */ @Override public void serialize(List<String> value, JsonGenerator jgen, SerializerProvider provider) throws IOException { final int len = value.size(); // [JACKSON-805] if ((len == 1) && provider.isEnabled(SerializationFeature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED)) { _serializeUnwrapped(value, jgen, provider); return; } jgen.writeStartArray(len); if (_serializer == null) { serializeContents(value, jgen, provider, len); } else { serializeUsingCustom(value, jgen, provider, len); } jgen.writeEndArray(); } private final void _serializeUnwrapped(List<String> value, JsonGenerator jgen, SerializerProvider provider) throws IOException { if (_serializer == null) { serializeContents(value, jgen

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.impl; import java.io.IOException; import java.util.*; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.annotation.JacksonStdImpl; import com.fasterxml.jackson.databind.introspect.AnnotatedMember; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonArrayFormatVisitor; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatTypes; import com.fasterxml.jackson.databind.jsontype.TypeSerializer; import com.fasterxml.jackson.databind.ser.ContextualSerializer; import com.fasterxml.jackson.databind.ser.std.StaticListSerializerBase; /** * Efficient implement for serializing {@link Collection}s that contain Strings. * The only complexity is due to possibility that serializer for {@link String} * may be overridde; because of this, logic is needed to ensure that the default * serializer is in use to use fastest mode, or if not, to defer to custom * String serializer. */ @JacksonStdImpl @SuppressWarnings("serial") public class StringCollectionSerializer extends StaticListSerializerBase<Collection<String>> implements ContextualSerializer { public final static StringCollectionSerializer instance = new StringCollectionSerializer(); protected final JsonSerializer<String> _serializer; /* /********************************************************** /* Life-cycle /********************************************************** */ protected StringCollectionSerializer() { this(null); } @SuppressWarnings("unchecked") protected StringCollectionSerializer(JsonSerializer<?> ser) { super(Collection.class); _serializer = (JsonSerializer<String>) ser; } @Override protected JsonNode contentSchema() { return createSchemaNode("string", true); } @Override protected void acceptContentVisitor(JsonArrayFormatVisitor visitor) throws JsonMappingException { visitor.itemsFormat(JsonFormatTypes.STRING); } /* /********************************************************** /* Post-processing /********************************************************** */ @Override public JsonSerializer<?> createContextual(SerializerProvider provider, BeanProperty property) throws JsonMappingException { /* 29-Sep-2012, tatu: Actually, we need to do much more context

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>ual * checking here since we finally know for sure the property, * and it may have overrides */ JsonSerializer<?> ser = null; // First: if we have a property, may have property-annotation overrides if (property != null) { AnnotatedMember m = property.getMember(); if (m != null) { Object serDef = provider.getAnnotationIntrospector().findContentSerializer(m); if (serDef != null) { ser = provider.serializerInstance(m, serDef); } } } if (ser == null) { ser = _serializer; } // #124: May have a content converter ser = findConvertingContentSerializer(provider, property, ser); if (ser == null) { ser = provider.findValueSerializer(String.class, property); } else { ser = provider.handleSecondaryContextualization(ser, property); } // Optimization: default serializer just writes String, so we can avoid a call: if (isDefaultSerializer(ser)) { ser = null; } // note: will never have TypeSerializer, because Strings are "natural" type if (ser == _serializer) { return this; } return new StringCollectionSerializer(ser); } /* /********************************************************** /* Actual serialization /********************************************************** */ @Override public void serialize(Collection<String> value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { // [JACKSON-805] final int len = value.size(); if ((len == 1) && provider.isEnabled(SerializationFeature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED)) { _serializeUnwrapped(value, jgen, provider); return; } jgen.writeStartArray(len); if (_serializer == null) { serializeContents(value, jgen, provider); } else { serializeUsingCustom(value, jgen, provider); } jgen.writeEndArray(); } private final void _serializeUnwrapped(Collection<String> value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { if (_serializer == null) { serializeContents(value, jgen,

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> } public int getAnnotationCount() { return 0; } @Override public int hashCode() { return _name.hashCode(); } @Override public boolean equals(Object o) { if (o == this) return true; if (o == null || o.getClass() != getClass()) return false; VirtualAnnotatedMember other = (VirtualAnnotatedMember) o; return (other._declaringClass == _declaringClass) && other._name.equals(_name); } @Override public String toString() { return "[field "+getFullName()+"]"; } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.impl; import java.io.IOException; import java.lang.reflect.Type; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper; import com.fasterxml.jackson.databind.jsontype.TypeSerializer; import com.fasterxml.jackson.databind.ser.std.StdSerializer; @SuppressWarnings("serial") public class UnknownSerializer extends StdSerializer<Object> { public UnknownSerializer() { super(Object.class); } @Override public void serialize(Object value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonMappingException { // 27-Nov-2009, tatu: As per [JACKSON-201] may or may not fail... if (provider.isEnabled(SerializationFeature.FAIL_ON_EMPTY_BEANS)) { failForEmpty(value); } // But if it's fine, we'll just output empty JSON Object: jgen.writeStartObject(); jgen.writeEndObject(); } @Override public final void serializeWithType(Object value, JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer) throws IOException, JsonGenerationException { if (provider.isEnabled(SerializationFeature.FAIL_ON_EMPTY_BEANS)) { failForEmpty(value); } typeSer.writeTypePrefixForObject(value, jgen); typeSer.writeTypeSuffixForObject(value, jgen); } @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) throws JsonMappingException { return null; } @Override public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException { visitor.expectAnyFormat(typeHint); } protected void failForEmpty(Object value) throws JsonMappingException { throw new JsonMappingException("No serializer found for class "+value.getClass().getName()+" and no properties discovered to create BeanSerializer (to avoid exception, disable SerializationFeature.FAIL_ON_EMPTY_BEANS) )"); } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.introspect; import java.util.Collection; import java.util.Map; import com.fasterxml.jackson.databind.AnnotationIntrospector; import com.fasterxml.jackson.databind.DeserializationConfig; import com.fasterxml.jackson.databind.JavaType; import com.fasterxml.jackson.databind.SerializationConfig; import com.fasterxml.jackson.databind.annotation.JsonPOJOBuilder; import com.fasterxml.jackson.databind.cfg.MapperConfig; import com.fasterxml.jackson.databind.type.SimpleType; import com.fasterxml.jackson.databind.util.LRUMap; public class BasicClassIntrospector extends ClassIntrospector implements java.io.Serializable { private static final long serialVersionUID = 1L; /* We keep a small set of pre-constructed descriptions to use for * common non-structured values, such as Numbers and Strings. * This is strictly performance optimization to reduce what is * usually one-time cost, but seems useful for some cases considering * simplicity. * * @since 2.4 */ protected final static BasicBeanDescription STRING_DESC; static { AnnotatedClass ac = AnnotatedClass.constructWithoutSuperTypes(String.class, null, null); STRING_DESC = BasicBeanDescription.forOtherUse(null, SimpleType.constructUnsafe(String.class), ac); } protected final static BasicBeanDescription BOOLEAN_DESC; static { AnnotatedClass ac = AnnotatedClass.constructWithoutSuperTypes(Boolean.TYPE, null, null); BOOLEAN_DESC = BasicBeanDescription.forOtherUse(null, SimpleType.constructUnsafe(Boolean.TYPE), ac); } protected final static BasicBeanDescription INT_DESC; static { AnnotatedClass ac = AnnotatedClass.constructWithoutSuperTypes(Integer.TYPE, null, null); INT_DESC = BasicBeanDescription.forOtherUse(null, SimpleType.constructUnsafe(Integer.TYPE), ac); } protected final static BasicBeanDescription LONG_DESC; static { AnnotatedClass ac = AnnotatedClass.constructWithoutSuperTypes(Long.TYPE, null, null); LONG_DESC = BasicBeanDescription.forOtherUse(null, SimpleType.constructUnsafe(Long.

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> cls = type.getRawClass(); if (cls.isPrimitive()) { if (cls == Boolean.TYPE) { return BOOLEAN_DESC; } if (cls == Integer.TYPE) { return INT_DESC; } if (cls == Long.TYPE) { return LONG_DESC; } } else { if (cls == String.class) { return STRING_DESC; } } return null; } /** * Helper method used to decide whether we can omit introspection * for members (methods, fields, constructors); we may do so for * a limited number of container types JDK provides. */ protected boolean _isStdJDKCollection(JavaType type) { if (!type.isContainerType() || type.isArrayType()) { return false; } Class<?> raw = type.getRawClass(); Package pkg = raw.getPackage(); if (pkg != null) { String pkgName = pkg.getName(); if (pkgName.startsWith("java.lang") || pkgName.startsWith("java.util")) { /* 23-Sep-2014, tatu: Should we be conservative here (minimal number * of matches), or ambitious? Let's do latter for now. */ if (Collection.class.isAssignableFrom(raw) || Map.class.isAssignableFrom(raw)) { return true; } } } return false; } protected BasicBeanDescription _findStdJdkCollectionDesc(MapperConfig<?> cfg, JavaType type, MixInResolver r) { if (_isStdJDKCollection(type)) { AnnotatedClass ac = AnnotatedClass.construct(type.getRawClass(), (cfg.isAnnotationProcessingEnabled() ? cfg.getAnnotationIntrospector() : null), r); return BasicBeanDescription.forOtherUse(cfg, type, ac); } return null; } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser; import java.io.IOException; import java.util.*; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.deser.impl.ObjectIdReader; import com.fasterxml.jackson.databind.deser.impl.ReadableObjectId; import com.fasterxml.jackson.databind.jsontype.TypeDeserializer; /** * Deserializer only used for abstract types used as placeholders during polymorphic * type handling deserialization. If so, there is no real deserializer associated * with nominal type, just {@link TypeDeserializer}; and any calls that do not * pass such resolver will result in an error. */ public class AbstractDeserializer extends JsonDeserializer<Object> implements java.io.Serializable { private static final long serialVersionUID = 1L; protected final JavaType _baseType; protected final ObjectIdReader _objectIdReader; protected final Map<String, SettableBeanProperty> _backRefProperties; // support for "native" types, which require special care: protected final boolean _acceptString; protected final boolean _acceptBoolean; protected final boolean _acceptInt; protected final boolean _acceptDouble; public AbstractDeserializer(BeanDeserializerBuilder builder, BeanDescription beanDesc, Map<String, SettableBeanProperty> backRefProps) { _baseType = beanDesc.getType(); _objectIdReader = builder.getObjectIdReader(); _backRefProperties = backRefProps; Class<?> cls = _baseType.getRawClass(); _acceptString = cls.isAssignableFrom(String.class); _acceptBoolean = (cls == Boolean.TYPE) || cls.isAssignableFrom(Boolean.class); _acceptInt = (cls == Integer.TYPE) || cls.isAssignableFrom(Integer.class); _acceptDouble = (cls == Double.TYPE) || cls.isAssignableFrom(Double.class); } protected AbstractDeserializer(BeanDescription beanDesc) { _baseType = beanDesc.getType(); _objectIdReader = null; _backRefProperties = null; Class<?> cls = _baseType.getRawClass(); _acceptString = cls.isAssignableFrom(String.class); _acceptBoolean = (cls == Boolean.TYPE) || cls.isAssignableFrom(Boolean

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>.class); _acceptInt = (cls == Integer.TYPE) || cls.isAssignableFrom(Integer.class); _acceptDouble = (cls == Double.TYPE) || cls.isAssignableFrom(Double.class); } /** * Factory method used when constructing instances for non-POJO types, like * {@link java.util.Map}s. * * @since 2.3 */ public static AbstractDeserializer constructForNonPOJO(BeanDescription beanDesc) { return new AbstractDeserializer(beanDesc); } /* /********************************************************** /* Public accessors /********************************************************** */ @Override public Class<?> handledType() { return _baseType.getRawClass(); } @Override public boolean isCachable() { return true; } /** * Overridden to return true for those instances that are * handling value for which Object Identity handling is enabled * (either via value type or referring property). */ @Override public ObjectIdReader getObjectIdReader() { return _objectIdReader; } /** * Method called by <code>BeanDeserializer</code> to resolve back reference * part of managed references. */ @Override public SettableBeanProperty findBackReference(String logicalName) { return (_backRefProperties == null) ? null : _backRefProperties.get(logicalName); } /* /********************************************************** /* Deserializer implementation /********************************************************** */ @Override public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException, JsonProcessingException { // Hmmh. One tricky question; for scalar, is it an Object Id, or "Natural" type? // for now, prefer Object Id: if (_objectIdReader != null) { JsonToken t = jp.getCurrentToken(); // should be good enough check; we only care about Strings, integral numbers: if (t != null && t.isScalarValue()) { return _deserializeFromObjectId(jp, ctxt); } } // First: support "natural" values (which are always serialized without type info!) Object result = _deserializeIfNatural(jp, ctxt); if (result != null) { return result; } return typeDeserializer.deserializeTypedFromObject(jp, ctxt); }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>AnnotatedMember m) { Boolean r = _primary.hasRequiredMarker(m); return (r == null) ? _secondary.hasRequiredMarker(m) : r; } // // // Serialization: general annotations @Override public Object findSerializer(Annotated am) { Object r = _primary.findSerializer(am); return _isExplicitClassOrOb(r, JsonSerializer.None.class) ? r : _secondary.findSerializer(am); } @Override public Object findKeySerializer(Annotated a) { Object r = _primary.findKeySerializer(a); return _isExplicitClassOrOb(r, JsonSerializer.None.class) ? r : _secondary.findKeySerializer(a); } @Override public Object findContentSerializer(Annotated a) { Object r = _primary.findContentSerializer(a); return _isExplicitClassOrOb(r, JsonSerializer.None.class) ? r : _secondary.findContentSerializer(a); } @Override public Object findNullSerializer(Annotated a) { Object r = _primary.findNullSerializer(a); return _isExplicitClassOrOb(r, JsonSerializer.None.class) ? r : _secondary.findNullSerializer(a); } @Override public JsonInclude.Include findSerializationInclusion(Annotated a, JsonInclude.Include defValue) { // note: call secondary first, to give lower priority defValue = _secondary.findSerializationInclusion(a, defValue); defValue = _primary.findSerializationInclusion(a, defValue); return defValue; } @Override public JsonInclude.Include findSerializationInclusionForContent(Annotated a, JsonInclude.Include defValue) { // note: call secondary first, to give lower priority defValue = _secondary.findSerializationInclusion(a, defValue); defValue = _primary.findSerializationInclusion(a, defValue); return defValue; } @Override public Class<?> findSerializationType(Annotated a) { Class<?> r = _primary.findSerializationType(a); return (r == null) ? _secondary.findSerializationType(a) : r; } @Override public Class<?> findSerializationKeyType(Annotated am,

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> */ @Override @Deprecated public Boolean findSerializationSortAlphabetically(AnnotatedClass ac) { Boolean r = _primary.findSerializationSortAlphabetically(ac); return (r == null) ? _secondary.findSerializationSortAlphabetically(ac) : r; } @Override public Boolean findSerializationSortAlphabetically(Annotated ann) { Boolean r = _primary.findSerializationSortAlphabetically(ann); return (r == null) ? _secondary.findSerializationSortAlphabetically(ann) : r; } @Override public void findAndAddVirtualProperties(MapperConfig<?> config, AnnotatedClass ac, List<BeanPropertyWriter> properties) { // first secondary, then primary, to give proper precedence _primary.findAndAddVirtualProperties(config, ac, properties); _secondary.findAndAddVirtualProperties(config, ac, properties); } // // // Serialization: property annotations @Override public PropertyName findNameForSerialization(Annotated a) { PropertyName n = _primary.findNameForSerialization(a); // note: "use default" should not block explicit answer, so: if (n == null) { n = _secondary.findNameForSerialization(a); } else if (n == PropertyName.USE_DEFAULT) { PropertyName n2 = _secondary.findNameForSerialization(a); if (n2 != null) { n = n2; } } return n; } @Override public boolean hasAsValueAnnotation(AnnotatedMethod am) { return _primary.hasAsValueAnnotation(am) || _secondary.hasAsValueAnnotation(am); } @Override public String findEnumValue(Enum<?> value) { String r = _primary.findEnumValue(value); return (r == null) ? _secondary.findEnumValue(value) : r; } // // // Deserialization: general annotations @Override public Object findDeserializer(Annotated am) { Object r = _primary.findDeserializer(am); return _isExplicitClassOrOb(r, JsonDeserializer.None.class) ? r : _secondary.findDeserializer(am); } @Override public Object findKeyDeserializer(Annotated am) { Object r = _primary.findKeyDeserializer(am); return

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> _isExplicitClassOrOb(r, KeyDeserializer.None.class) ? r : _secondary.findKeyDeserializer(am); } @Override public Object findContentDeserializer(Annotated am) { Object r = _primary.findContentDeserializer(am); return _isExplicitClassOrOb(r, JsonDeserializer.None.class) ? r : _secondary.findContentDeserializer(am); } @Override public Class<?> findDeserializationType(Annotated am, JavaType baseType) { Class<?> r = _primary.findDeserializationType(am, baseType); return (r != null) ? r : _secondary.findDeserializationType(am, baseType); } @Override public Class<?> findDeserializationKeyType(Annotated am, JavaType baseKeyType) { Class<?> result = _primary.findDeserializationKeyType(am, baseKeyType); return (result == null) ? _secondary.findDeserializationKeyType(am, baseKeyType) : result; } @Override public Class<?> findDeserializationContentType(Annotated am, JavaType baseContentType) { Class<?> result = _primary.findDeserializationContentType(am, baseContentType); return (result == null) ? _secondary.findDeserializationContentType(am, baseContentType) : result; } @Override public Object findDeserializationConverter(Annotated a) { Object ob = _primary.findDeserializationConverter(a); return (ob == null) ? _secondary.findDeserializationConverter(a) : ob; } @Override public Object findDeserializationContentConverter(AnnotatedMember a) { Object ob = _primary.findDeserializationContentConverter(a); return (ob == null) ? _secondary.findDeserializationContentConverter(a) : ob; } // // // Deserialization: class annotations @Override public Object findValueInstantiator(AnnotatedClass ac) { Object result = _primary.findValueInstantiator(ac); return (result == null) ? _secondary.findValueInstantiator(ac) : result; } @Override public Class<?> findPOJOBuilder(AnnotatedClass ac) { Class<?> result = _primary.findPOJOBuilder(ac); return (result == null) ? _secondary.findPOJOBuilder(ac) : result; } @Override public JsonPOJOBuilder.Value findPOJO

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> _typeNames = null; _typeParameters = null; } else { _typeNames = typeNames; _typeParameters = typeParams; } _typeParametersFor = parametersFrom; } /** * Method used by core Jackson classes: NOT to be used by application code. *<p> * NOTE: public only because it is called by <code>ObjectMapper</code> which is * not in same package */ public static SimpleType constructUnsafe(Class<?> raw) { return new SimpleType(raw, null, null, null, null, false, null); } @Override protected JavaType _narrow(Class<?> subclass) { // Should we check that there is a sub-class relationship? return new SimpleType(subclass, _typeNames, _typeParameters, _valueHandler, _typeHandler, _asStatic, _typeParametersFor); } @Override public JavaType narrowContentsBy(Class<?> subclass) { // should never get called throw new IllegalArgumentException("Internal error: SimpleType.narrowContentsBy() should never be called"); } @Override public JavaType widenContentsBy(Class<?> subclass) { // should never get called throw new IllegalArgumentException("Internal error: SimpleType.widenContentsBy() should never be called"); } public static SimpleType construct(Class<?> cls) { /* Let's add sanity checks, just to ensure no * Map/Collection entries are constructed */ if (Map.class.isAssignableFrom(cls)) { throw new IllegalArgumentException("Can not construct SimpleType for a Map (class: "+cls.getName()+")"); } if (Collection.class.isAssignableFrom(cls)) { throw new IllegalArgumentException("Can not construct SimpleType for a Collection (class: "+cls.getName()+")"); } // ... and while we are at it, not array types either if (cls.isArray()) { throw new IllegalArgumentException("Can not construct SimpleType for an array (class: "+cls.getName()+")"); } return new SimpleType(cls); } @Override public SimpleType withTypeHandler(Object h) { return new SimpleType(_class, _typeNames, _typeParameters, _valueHandler, h, _asStatic, _typeParametersFor); } @

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>Override public JavaType withContentTypeHandler(Object h) { // no content type, so: throw new IllegalArgumentException("Simple types have no content types; can not call withContenTypeHandler()"); } @Override public SimpleType withValueHandler(Object h) { if (h == _valueHandler) { return this; } return new SimpleType(_class, _typeNames, _typeParameters, h, _typeHandler, _asStatic, _typeParametersFor); } @Override public SimpleType withContentValueHandler(Object h) { // no content type, so: throw new IllegalArgumentException("Simple types have no content types; can not call withContenValueHandler()"); } @Override public SimpleType withStaticTyping() { return _asStatic ? this : new SimpleType(_class, _typeNames, _typeParameters, _valueHandler, _typeHandler, _asStatic, _typeParametersFor); } @Override protected String buildCanonicalName() { StringBuilder sb = new StringBuilder(); sb.append(_class.getName()); if (_typeParameters != null && _typeParameters.length > 0) { sb.append('<'); boolean first = true; for (JavaType t : _typeParameters) { if (first) { first = false; } else { sb.append(','); } sb.append(t.toCanonical()); } sb.append('>'); } return sb.toString(); } /* /********************************************************** /* Public API /********************************************************** */ @Override public boolean isContainerType() { return false; } @Override public int containedTypeCount() { return (_typeParameters == null) ? 0 : _typeParameters.length; } @Override public JavaType containedType(int index) { if (index < 0 || _typeParameters == null || index >= _typeParameters.length) { return null; } return _typeParameters[index]; } @Override public String containedTypeName(int index) { if (index < 0 || _typeNames == null || index >= _typeNames.length) { return null; } return _typeNames[index]; } @Override public Class<?> getParameterSource

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>() { return _typeParametersFor; } @Override public StringBuilder getErasedSignature(StringBuilder sb) { return _classSignature(_class, sb, true); } @Override public StringBuilder getGenericSignature(StringBuilder sb) { _classSignature(_class, sb, false); if (_typeParameters != null) { sb.append('<'); for (JavaType param : _typeParameters) { sb = param.getGenericSignature(sb); } sb.append('>'); } sb.append(';'); return sb; } /* /********************************************************** /* Standard methods /********************************************************** */ @Override public String toString() { StringBuilder sb = new StringBuilder(40); sb.append("[simple type, class ").append(buildCanonicalName()).append(']'); return sb.toString(); } @Override public boolean equals(Object o) { if (o == this) return true; if (o == null) return false; if (o.getClass() != getClass()) return false; SimpleType other = (SimpleType) o; // Classes must be identical... if (other._class != this._class) return false; // And finally, generic bindings, if any JavaType[] p1 = _typeParameters; JavaType[] p2 = other._typeParameters; if (p1 == null) { return (p2 == null) || p2.length == 0; } if (p2 == null) return false; if (p1.length != p2.length) return false; for (int i = 0, len = p1.length; i < len; ++i) { if (!p1[i].equals(p2[i])) { return false; } } return true; } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.util; import com.fasterxml.jackson.databind.introspect.AnnotatedMethod; /** * Helper class that contains functionality needed by both serialization * and deserialization side. */ public class BeanUtil { /* /********************************************************** /* Handling property names /********************************************************** */ /** * @since 2.5 */ public static String okNameForGetter(AnnotatedMethod am, boolean stdNaming) { String name = am.getName(); String str = okNameForIsGetter(am, name, stdNaming); if (str == null) { str = okNameForRegularGetter(am, name, stdNaming); } return str; } /** * @since 2.5 */ public static String okNameForRegularGetter(AnnotatedMethod am, String name, boolean stdNaming) { if (name.startsWith("get")) { /* 16-Feb-2009, tatu: To handle [JACKSON-53], need to block * CGLib-provided method "getCallbacks". Not sure of exact * safe criteria to get decent coverage without false matches; * but for now let's assume there's no reason to use any * such getter from CGLib. * But let's try this approach... */ if ("getCallbacks".equals(name)) { if (isCglibGetCallbacks(am)) { return null; } } else if ("getMetaClass".equals(name)) { // 30-Apr-2009, tatu: Need to suppress serialization of a cyclic reference if (isGroovyMetaClassGetter(am)) { return null; } } return stdNaming ? stdManglePropertyName(name, 3) : legacyManglePropertyName(name, 3); } return null; } /** * @since 2.5 */ public static String okNameForIsGetter(AnnotatedMethod am, String name, boolean stdNaming) { if (name.startsWith("is")) { // plus, must return a boolean Class<?> rt = am.getRawType(); if (rt == Boolean.class || rt == Boolean.TYPE) {

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>getParameterCount() != 1) { continue; } _doAddInjectable(ai.findInjectableValueId(m), m); } } protected void _doAddInjectable(Object id, AnnotatedMember m) { if (id == null) { return; } if (_injectables == null) { _injectables = new LinkedHashMap<Object, AnnotatedMember>(); } AnnotatedMember prev = _injectables.put(id, m); if (prev != null) { String type = id.getClass().getName(); throw new IllegalArgumentException("Duplicate injectable value with id '" +String.valueOf(id)+"' (of type "+type+")"); } } private PropertyName _propNameFromSimple(String simpleName) { return PropertyName.construct(simpleName, null); } /* /********************************************************** /* Internal methods; removing ignored properties /********************************************************** */ /** * Method called to get rid of candidate properties that are marked * as ignored, or that are not visible. */ protected void _removeUnwantedProperties() { Iterator<Map.Entry<String,POJOPropertyBuilder>> it = _properties.entrySet().iterator(); final boolean forceNonVisibleRemoval = !_config.isEnabled(MapperFeature.INFER_PROPERTY_MUTATORS); while (it.hasNext()) { Map.Entry<String, POJOPropertyBuilder> entry = it.next(); POJOPropertyBuilder prop = entry.getValue(); // First: if nothing visible, just remove altogether if (!prop.anyVisible()) { it.remove(); continue; } // Otherwise, check ignorals if (prop.anyIgnorals()) { // first: if one or more ignorals, and no explicit markers, remove the whole thing if (!prop.isExplicitlyIncluded()) { it.remove(); _addIgnored(prop.getName()); continue; } // otherwise just remove ones marked to be ignored prop.removeIgnored(); if (!_forSerialization && !prop.couldDeserialize()) { _addIgnored(prop.getName()); } } // and finally, handle removal of individual non-visible elements prop.removeNonVisible(forceNonVisibleRemoval); } } private void _addIgnored(String name

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>prop == null) { prop = new POJOPropertyBuilder(new PropertyName(implName), _annotationIntrospector, _forSerialization); _properties.put(implName, prop); } return prop; } private PropertyNamingStrategy _findNamingStrategy() { Object namingDef = (_annotationIntrospector == null)? null : _annotationIntrospector.findNamingStrategy(_classDef); if (namingDef == null) { return _config.getPropertyNamingStrategy(); } if (namingDef instanceof PropertyNamingStrategy) { return (PropertyNamingStrategy) namingDef; } /* Alas, there's no way to force return type of "either class * X or Y" -- need to throw an exception after the fact */ if (!(namingDef instanceof Class)) { throw new IllegalStateException("AnnotationIntrospector returned PropertyNamingStrategy definition of type " +namingDef.getClass().getName()+"; expected type PropertyNamingStrategy or Class<PropertyNamingStrategy> instead"); } Class<?> namingClass = (Class<?>)namingDef; if (!PropertyNamingStrategy.class.isAssignableFrom(namingClass)) { throw new IllegalStateException("AnnotationIntrospector returned Class " +namingClass.getName()+"; expected Class<PropertyNamingStrategy>"); } HandlerInstantiator hi = _config.getHandlerInstantiator(); if (hi != null) { PropertyNamingStrategy pns = hi.namingStrategyInstance(_config, _classDef, namingClass); if (pns != null) { return pns; } } return (PropertyNamingStrategy) ClassUtil.createInstance(namingClass, _config.canOverrideAccessModifiers()); } protected void _updateCreatorProperty(POJOPropertyBuilder prop, List<POJOPropertyBuilder> creatorProperties) { if (creatorProperties != null) { for (int i = 0, len = creatorProperties.size(); i < len; ++i) { if (creatorProperties.get(i).getInternalName().equals(prop.getInternalName())) { creatorProperties.set(i, prop); break; } } } } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.type; import java.util.Collection; import com.fasterxml.jackson.databind.JavaType; /** * Type that represents things that act similar to {@link java.util.Collection}; * but may or may not be instances of that interface. * This specifically allows framework to check for configuration and annotation * settings used for Map types, and pass these to custom handlers that may be more * familiar with actual type. */ public class CollectionLikeType extends TypeBase { private static final long serialVersionUID = 4611641304150899138L; /** * Type of elements in collection */ protected final JavaType _elementType; /* /********************************************************** /* Life-cycle /********************************************************** */ protected CollectionLikeType(Class<?> collT, JavaType elemT, Object valueHandler, Object typeHandler, boolean asStatic) { super(collT, elemT.hashCode(), valueHandler, typeHandler, asStatic); _elementType = elemT; } @Override protected JavaType _narrow(Class<?> subclass) { return new CollectionLikeType(subclass, _elementType, _valueHandler, _typeHandler, _asStatic); } @Override public JavaType narrowContentsBy(Class<?> contentClass) { // Can do a quick check first: if (contentClass == _elementType.getRawClass()) { return this; } return new CollectionLikeType(_class, _elementType.narrowBy(contentClass), _valueHandler, _typeHandler, _asStatic); } @Override public JavaType widenContentsBy(Class<?> contentClass) { // Can do a quick check first: if (contentClass == _elementType.getRawClass()) { return this; } return new CollectionLikeType(_class, _elementType.widenBy(contentClass), _valueHandler, _typeHandler, _asStatic); } public static CollectionLikeType construct(Class<?> rawType, JavaType elemT) { // nominally component types will be just Object.class return new CollectionLikeType(rawType, elemT, null, null, false); } @Override public CollectionLikeType withTypeHandler(Object

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> h) { return new CollectionLikeType(_class, _elementType, _valueHandler, h, _asStatic); } @Override public CollectionLikeType withContentTypeHandler(Object h) { return new CollectionLikeType(_class, _elementType.withTypeHandler(h), _valueHandler, _typeHandler, _asStatic); } @Override public CollectionLikeType withValueHandler(Object h) { return new CollectionLikeType(_class, _elementType, h, _typeHandler, _asStatic); } @Override public CollectionLikeType withContentValueHandler(Object h) { return new CollectionLikeType(_class, _elementType.withValueHandler(h), _valueHandler, _typeHandler, _asStatic); } @Override public CollectionLikeType withStaticTyping() { if (_asStatic) { return this; } return new CollectionLikeType(_class, _elementType.withStaticTyping(), _valueHandler, _typeHandler, true); } /* /********************************************************** /* Public API /********************************************************** */ @Override public boolean isContainerType() { return true; } @Override public boolean isCollectionLikeType() { return true; } @Override public JavaType getContentType() { return _elementType; } @Override public int containedTypeCount() { return 1; } @Override public JavaType containedType(int index) { return (index == 0) ? _elementType : null; } /** * Not sure if we should count on this, but type names * for core interfaces use "E" for element type */ @Override public String containedTypeName(int index) { if (index == 0) return "E"; return null; } // TODO: should allow construction of instances that do refer // to parameterization, since it is NOT Collection @Override public Class<?> getParameterSource() { return null; } @Override public StringBuilder getErasedSignature(StringBuilder sb) { return _classSignature(_class, sb, true); } @Override public StringBuilder getGenericSignature(StringBuilder sb) { _classSignature(_class, sb, false); sb.append('<'); _elementType.getGenericSignature(sb); sb.append

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>(">;"); return sb; } @Override protected String buildCanonicalName() { StringBuilder sb = new StringBuilder(); sb.append(_class.getName()); if (_elementType != null) { sb.append('<'); sb.append(_elementType.toCanonical()); sb.append('>'); } return sb.toString(); } /* /********************************************************** /* Extended API /********************************************************** */ /** * Method that can be used for checking whether this type is a * "real" Collection type; meaning whether it represents a parameterized * subtype of {@link java.util.Collection} or just something that acts * like one. */ public boolean isTrueCollectionType() { return Collection.class.isAssignableFrom(_class); } /* /********************************************************** /* Standard methods /********************************************************** */ @Override public boolean equals(Object o) { if (o == this) return true; if (o == null) return false; if (o.getClass() != getClass()) return false; CollectionLikeType other = (CollectionLikeType) o; return (_class == other._class) && _elementType.equals(other._elementType); } @Override public String toString() { return "[collection-like type; class "+_class.getName()+", contains "+_elementType+"]"; } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser.std; import java.io.IOException; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.DeserializationContext; import com.fasterxml.jackson.databind.DeserializationFeature; import com.fasterxml.jackson.databind.annotation.JacksonStdImpl; import com.fasterxml.jackson.databind.jsontype.TypeDeserializer; @JacksonStdImpl public final class StringDeserializer extends StdScalarDeserializer<String> { private static final long serialVersionUID = 1L; /** * @since 2.2 */ public final static StringDeserializer instance = new StringDeserializer(); public StringDeserializer() { super(String.class); } @Override public String deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException { JsonToken curr = jp.getCurrentToken(); if (curr == JsonToken.VALUE_STRING) { return jp.getText(); } // Issue#381 if (curr == JsonToken.START_ARRAY && ctxt.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS)) { jp.nextToken(); final String parsed = _parseString(jp, ctxt); if (jp.nextToken() != JsonToken.END_ARRAY) { throw ctxt.wrongTokenException(jp, JsonToken.END_ARRAY, "Attempted to unwrap single value array for single 'String' value but there was more than a single value in the array"); } return parsed; } // [JACKSON-330]: need to gracefully handle byte[] data, as base64 if (curr == JsonToken.VALUE_EMBEDDED_OBJECT) { Object ob = jp.getEmbeddedObject(); if (ob == null) { return null; } if (ob instanceof byte[]) { return Base64Variants.getDefaultVariant().encode((byte[]) ob, false); } // otherwise, try conversion using toString()... return ob.toString(); } // allow coercions for other scalar types String text = jp.getValueAsString(); if (text != null) { return text; } throw ctxt.mappingException(_valueClass, curr); } // 1.6: since we can never have type info

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> public Object getTypeId() { return getClass().getName(); } /* /********************************************************** /* Life-cycle: registration /********************************************************** */ /** * Method called by {@link ObjectMapper} when module is registered. * It is called to let module register functionality it provides, * using callback methods passed-in context object exposes. */ public abstract void setupModule(SetupContext context); /* /********************************************************** /* Helper types /********************************************************** */ /** * Interface Jackson exposes to modules for purpose of registering * extended functionality. * Usually implemented by {@link ObjectMapper}, but modules should * NOT rely on this -- if they do require access to mapper instance, * they need to call {@link SetupContext#getOwner} method. */ public static interface SetupContext { /* /********************************************************** /* Simple accessors /********************************************************** */ /** * Method that returns version information about {@link ObjectMapper} * that implements this context. Modules can use this to choose * different settings or initialization order; or even decide to fail * set up completely if version is compatible with module. */ public Version getMapperVersion(); /** * Fallback access method that allows modules to refer to the * {@link ObjectMapper} that provided this context. * It should NOT be needed by most modules; and ideally should * not be used -- however, there may be cases where this may * be necessary due to various design constraints. *<p> * NOTE: use of this method is discouraged, as it allows access to * things Modules typically should not modify. It is included, however, * to allow access to new features in cases where Module API * has not yet been extended, or there are oversights. *<p> * Return value is chosen to not leak dependency to {@link ObjectMapper}; * however, instance will always be of that type. * This is why return value is declared generic, to allow caller to * specify context to often avoid casting. * * @since 2.0 */ public <C extends ObjectCodec> C getOwner(); /** * Accessor for finding {@link TypeFactory} that is currently configured * by the context. *<p> * NOTE: since it is possible that other modules might change or replace

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>NullValue(); } else if (typeDeser == null) { value = valueDes.deserialize(jp, ctxt); } else { value = valueDes.deserializeWithType(jp, ctxt, typeDeser); } } catch (Exception e) { wrapAndThrow(e, Map.Entry.class, keyStr); } // Close, but also verify that we reached the END_OBJECT t = jp.nextToken(); if (t != JsonToken.END_OBJECT) { if (t == JsonToken.FIELD_NAME) { // most likely throw ctxt.mappingException("Problem binding JSON into Map.Entry: more than one entry in JSON (second field: '"+jp.getCurrentName()+"')"); } // how would this occur? throw ctxt.mappingException("Problem binding JSON into Map.Entry: unexpected content after JSON Object entry: "+t); } return new AbstractMap.SimpleEntry<Object,Object>(key, value); } @Override public Map.Entry<Object,Object> deserialize(JsonParser jp, DeserializationContext ctxt, Map.Entry<Object,Object> result) throws IOException { throw new IllegalStateException("Can not update Map.Entry values"); } @Override public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException, JsonProcessingException { // In future could check current token... for now this should be enough: return typeDeserializer.deserializeTypedFromObject(jp, ctxt); } /* /********************************************************** /* Other public accessors /********************************************************** */ @Override public JavaType getValueType() { return _type; } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.type; import java.util.*; import java.lang.reflect.*; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.JavaType; import com.fasterxml.jackson.databind.util.ArrayBuilders; import com.fasterxml.jackson.databind.util.LRUMap; /** * Class used for creating concrete {@link JavaType} instances, * given various inputs. *<p> * Instances of this class are accessible using {@link com.fasterxml.jackson.databind.ObjectMapper} * as well as many objects it constructs (like * {@link com.fasterxml.jackson.databind.DeserializationConfig} and * {@link com.fasterxml.jackson.databind.SerializationConfig})), * but usually those objects also * expose convenience methods (<code>constructType</code>). * So, you can do for example: *<pre> * JavaType stringType = mapper.constructType(String.class); *</pre> * However, more advanced methods are only exposed by factory so that you * may need to use: *<pre> * JavaType stringCollection = mapper.getTypeFactory().constructCollectionType(List.class, String.class); *</pre> */ @SuppressWarnings({"rawtypes", "unchecked"}) public final class TypeFactory implements java.io.Serializable { private static final long serialVersionUID = 1L; private final static JavaType[] NO_TYPES = new JavaType[0]; /** * Globally shared singleton. Not accessed directly; non-core * code should use per-ObjectMapper instance (via configuration objects). * Core Jackson code uses {@link #defaultInstance} for accessing it. */ protected final static TypeFactory instance = new TypeFactory(); /* /********************************************************** /* Caching /********************************************************** */ // // // Let's assume that a small set of core primitive/basic types // // // will not be modified, and can be freely shared to streamline // // // parts of processing protected final static SimpleType CORE_TYPE_STRING = new SimpleType(String.class); protected final static SimpleType CORE_TYPE_BOOL = new SimpleType(Boolean.TYPE); protected final static SimpleType CORE_

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> instanceof SimpleType) { // and only if subclass is an array, Collection or Map if (subclass.isArray() || Map.class.isAssignableFrom(subclass) || Collection.class.isAssignableFrom(subclass)) { // need to assert type compatibility... if (!baseType.getRawClass().isAssignableFrom(subclass)) { throw new IllegalArgumentException("Class "+subclass.getClass().getName()+" not subtype of "+baseType); } // this _should_ work, right? JavaType subtype = _fromClass(subclass, new TypeBindings(this, baseType.getRawClass())); // one more thing: handlers to copy? Object h = baseType.getValueHandler(); if (h != null) { subtype = subtype.withValueHandler(h); } h = baseType.getTypeHandler(); if (h != null) { subtype = subtype.withTypeHandler(h); } return subtype; } } // otherwise regular narrowing should work just fine return baseType.narrowBy(subclass); } /** * Factory method for constructing a {@link JavaType} out of its canonical * representation (see {@link JavaType#toCanonical()}). * * @param canonical Canonical string representation of a type * * @throws IllegalArgumentException If canonical representation is malformed, * or class that type represents (including its generic parameters) is * not found */ public JavaType constructFromCanonical(String canonical) throws IllegalArgumentException { return _parser.parse(canonical); } /** * Method that is to figure out actual type parameters that given * class binds to generic types defined by given (generic) * interface or class. * This could mean, for example, trying to figure out * key and value types for Map implementations. * * @param type Sub-type (leaf type) that implements <code>expType</code> */ public JavaType[] findTypeParameters(JavaType type, Class<?> expType) { /* Tricky part here is that some JavaType instances have been constructed * from generic type (usually via TypeReference); and in those case * types have been resolved. Alternative is that the leaf type is type-erased * class, in which case this has not been done. * For now simplest way to handle this is to split

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>>></code>, you could * call *<pre> * JavaType inner = TypeFactory.parametricType(Set.class, Integer.class); * TypeFactory.parametricType(List.class, inner); *</pre> *<p> * NOTE: type modifiers are NOT called on constructed type itself; but are called * for contained types. * * * @param parametrized Actual full type * @param parametersFor class or interface for which type parameters are applied; either * <code>parametrized</code> or one of its supertypes * @param parameterTypes Type parameters to apply * * @since 2.5 */ public JavaType constructParametrizedType(Class<?> parametrized, Class<?> parametersFor, JavaType... parameterTypes) { JavaType resultType; // Need to check kind of class we are dealing with... if (parametrized.isArray()) { // 19-Jan-2010, tatus: should we support multi-dimensional arrays directly? if (parameterTypes.length != 1) { throw new IllegalArgumentException("Need exactly 1 parameter type for arrays ("+parametrized.getName()+")"); } resultType = constructArrayType(parameterTypes[0]); } else if (Map.class.isAssignableFrom(parametrized)) { if (parameterTypes.length != 2) { throw new IllegalArgumentException("Need exactly 2 parameter types for Map types ("+parametrized.getName()+")"); } resultType = constructMapType((Class<Map<?,?>>)parametrized, parameterTypes[0], parameterTypes[1]); } else if (Collection.class.isAssignableFrom(parametrized)) { if (parameterTypes.length != 1) { throw new IllegalArgumentException("Need exactly 1 parameter type for Collection types ("+parametrized.getName()+")"); } resultType = constructCollectionType((Class<Collection<?>>)parametrized, parameterTypes[0]); } else { resultType = constructSimpleType(parametrized, parametersFor, parameterTypes); } return resultType; } /** * @deprecated Since 2.5, use {@link #constructParametrizedType} instead. */ @Deprecated public JavaType constructParametricType(Class

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> that its * parameterization is unknown. * This is similar to using <code>Object.class</code> parameterization, * and is equivalent to calling: *<pre> * typeFactory.constructMapLikeType(collectionClass, typeFactory.unknownType(), typeFactory.unknownType()); *<pre> *<p> * This method should only be used if parameterization is completely unavailable. */ public MapLikeType constructRawMapLikeType(Class<?> mapClass) { return MapLikeType.construct(mapClass, unknownType(), unknownType()); } /* /********************************************************** /* Actual factory methods /********************************************************** */ /** * @param context Mapping of formal parameter declarations (for generic * types) into actual types */ protected JavaType _fromClass(Class<?> clz, TypeBindings context) { // Very first thing: small set of core types we know well: if (clz == String.class) return CORE_TYPE_STRING; if (clz == Boolean.TYPE) return CORE_TYPE_BOOL; if (clz == Integer.TYPE) return CORE_TYPE_INT; if (clz == Long.TYPE) return CORE_TYPE_LONG; // Barring that, we may have recently constructed an instance: ClassKey key = new ClassKey(clz); JavaType result = _typeCache.get(key); // ok, cache object is synced if (result != null) { return result; } // If context was needed, weed do: /* if (context == null) { context = new TypeBindings(this, cls); } */ // First: do we have an array type? if (clz.isArray()) { result = ArrayType.construct(_constructType(clz.getComponentType(), null), null, null); /* Also: although enums can also be fully resolved, there's little * point in doing so (T extends Enum<T>) etc. */ } else if (clz.isEnum()) { result = new SimpleType(clz); /* Maps and Collections aren't quite as hot; problem is, due * to type erasure we often do not know typing and can only assume * base Object. */ } else

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> if (Map.class.isAssignableFrom(clz)) { result = _mapType(clz); } else if (Collection.class.isAssignableFrom(clz)) { result = _collectionType(clz); } else { // 29-Sep-2014, tatu: We may want to pre-resolve well-known generic types if (Map.Entry.class.isAssignableFrom(clz)) { JavaType[] pts = this.findTypeParameters(clz, Map.Entry.class); JavaType kt, vt; if (pts == null || pts.length != 2) { kt = vt = unknownType(); } else { kt = pts[0]; vt = pts[1]; } result = constructSimpleType(clz, Map.Entry.class, new JavaType[] { kt, vt }); } else { result = new SimpleType(clz); } } _typeCache.put(key, result); // cache object syncs return result; } /** * Method used by {@link TypeParser} when generics-aware version * is constructed. */ protected JavaType _fromParameterizedClass(Class<?> clz, List<JavaType> paramTypes) { if (clz.isArray()) { // ignore generics (should never have any) return ArrayType.construct(_constructType(clz.getComponentType(), null), null, null); } if (clz.isEnum()) { // ditto for enums return new SimpleType(clz); } if (Map.class.isAssignableFrom(clz)) { // First: if we do have param types, use them JavaType keyType, contentType; if (paramTypes.size() > 0) { keyType = paramTypes.get(0); contentType = (paramTypes.size() >= 2) ? paramTypes.get(1) : _unknownType(); return MapType.construct(clz, keyType, contentType); } return _mapType(clz); } if (Collection.class.isAssignableFrom(clz)) { if (paramTypes.size() >= 1) { return CollectionType.construct(clz, paramTypes.get(0)); } return

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> _collectionType(clz); } if (paramTypes.size() == 0) { return new SimpleType(clz); } // Hmmh. Does this actually occur? JavaType[] pt = paramTypes.toArray(new JavaType[paramTypes.size()]); return constructSimpleType(clz, clz, pt); } /** * This method deals with parameterized types, that is, * first class generic classes. */ protected JavaType _fromParamType(ParameterizedType type, TypeBindings context) { /* First: what is the actual base type? One odd thing * is that 'getRawType' returns Type, not Class<?> as * one might expect. But let's assume it is always of * type Class: if not, need to add more code to resolve * it to Class. */ Class<?> rawType = (Class<?>) type.getRawType(); Type[] args = type.getActualTypeArguments(); int paramCount = (args == null) ? 0 : args.length; JavaType[] pt; if (paramCount == 0) { pt = NO_TYPES; } else { pt = new JavaType[paramCount]; for (int i = 0; i < paramCount; ++i) { pt[i] = _constructType(args[i], context); } } // Ok: Map or Collection? if (Map.class.isAssignableFrom(rawType)) { JavaType subtype = constructSimpleType(rawType, rawType, pt); JavaType[] mapParams = findTypeParameters(subtype, Map.class); if (mapParams.length != 2) { throw new IllegalArgumentException("Could not find 2 type parameters for Map class "+rawType.getName()+" (found "+mapParams.length+")"); } return MapType.construct(rawType, mapParams[0], mapParams[1]); } if (Collection.class.isAssignableFrom(rawType)) { JavaType subtype = constructSimpleType(rawType, rawType, pt); JavaType[] collectionParams = findTypeParameters(subtype, Collection.class); if (collectionParams.length != 1) { throw new IllegalArgumentException("Could not find 1 type parameter for Collection class "+rawType.getName()+"

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> is need. /* 29-Jan-2010, tatu: One more problem are recursive types * (T extends Comparable<T>). Need to add "placeholder" * for resolution to catch those. */ context._addPlaceholder(name); return _constructType(bounds[0], context); } protected JavaType _fromWildcard(WildcardType type, TypeBindings context) { /* Similar to challenges with TypeVariable, we may have * multiple upper bounds. But it is also possible that if * upper bound defaults to Object, we might want to consider * lower bounds instead. * * For now, we won't try anything more advanced; above is * just for future reference. */ return _constructType(type.getUpperBounds()[0], context); } private JavaType _mapType(Class<?> rawClass) { JavaType[] typeParams = findTypeParameters(rawClass, Map.class); // ok to have no types ("raw") if (typeParams == null) { return MapType.construct(rawClass, _unknownType(), _unknownType()); } // but exactly 2 types if any found if (typeParams.length != 2) { throw new IllegalArgumentException("Strange Map type "+rawClass.getName()+": can not determine type parameters"); } return MapType.construct(rawClass, typeParams[0], typeParams[1]); } private JavaType _collectionType(Class<?> rawClass) { JavaType[] typeParams = findTypeParameters(rawClass, Collection.class); // ok to have no types ("raw") if (typeParams == null) { return CollectionType.construct(rawClass, _unknownType()); } // but exactly 2 types if any found if (typeParams.length != 1) { throw new IllegalArgumentException("Strange Collection type "+rawClass.getName()+": can not determine type parameters"); } return CollectionType.construct(rawClass, typeParams[0]); } protected JavaType _resolveVariableViaSubTypes(HierarchicType leafType, String variableName, TypeBindings bindings) { // can't resolve raw types; possible to have as-of-yet-unbound types too: if (leafType != null &&

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> leafType.isGeneric()) { TypeVariable<?>[] typeVariables = leafType.getRawClass().getTypeParameters(); for (int i = 0, len = typeVariables.length; i < len; ++i) { TypeVariable<?> tv = typeVariables[i]; if (variableName.equals(tv.getName())) { // further resolution needed? Type type = leafType.asGeneric().getActualTypeArguments()[i]; if (type instanceof TypeVariable<?>) { return _resolveVariableViaSubTypes(leafType.getSubType(), ((TypeVariable<?>) type).getName(), bindings); } // no we're good for the variable (but it may have parameterization of its own) return _constructType(type, bindings); } } } return _unknownType(); } protected JavaType _unknownType() { return new SimpleType(Object.class); } /* /********************************************************** /* Helper methods /********************************************************** */ /** * Helper method used to find inheritance (implements, extends) path * between given types, if one exists (caller generally checks before * calling this method). Returned type represents given <b>subtype</b>, * with supertype linkage extending to <b>supertype</b>. */ protected HierarchicType _findSuperTypeChain(Class<?> subtype, Class<?> supertype) { // If super-type is a class (not interface), bit simpler if (supertype.isInterface()) { return _findSuperInterfaceChain(subtype, supertype); } return _findSuperClassChain(subtype, supertype); } protected HierarchicType _findSuperClassChain(Type currentType, Class<?> target) { HierarchicType current = new HierarchicType(currentType); Class<?> raw = current.getRawClass(); if (raw == target) { return current; } // Otherwise, keep on going down the rat hole... Type parent = raw.getGenericSuperclass(); if (parent != null) { HierarchicType sup = _findSuperClassChain(parent, target); if (sup != null) { sup.setSubType(current); current.setSuperType(sup); return current; } } return null; }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> protected HierarchicType _findSuperInterfaceChain(Type currentType, Class<?> target) { HierarchicType current = new HierarchicType(currentType); Class<?> raw = current.getRawClass(); if (raw == target) { return new HierarchicType(currentType); } // Otherwise, keep on going down the rat hole; first implemented interfaces /* 16-Aug-2011, tatu: Minor optimization based on profiled hot spot; let's * try caching certain commonly needed cases */ if (raw == HashMap.class) { if (target == Map.class) { return _hashMapSuperInterfaceChain(current); } } if (raw == ArrayList.class) { if (target == List.class) { return _arrayListSuperInterfaceChain(current); } } return _doFindSuperInterfaceChain(current, target); } protected HierarchicType _doFindSuperInterfaceChain(HierarchicType current, Class<?> target) { Class<?> raw = current.getRawClass(); Type[] parents = raw.getGenericInterfaces(); // as long as there are superclasses // and unless we have already seen the type (<T extends X<T>>) if (parents != null) { for (Type parent : parents) { HierarchicType sup = _findSuperInterfaceChain(parent, target); if (sup != null) { sup.setSubType(current); current.setSuperType(sup); return current; } } } // and then super-class if any Type parent = raw.getGenericSuperclass(); if (parent != null) { HierarchicType sup = _findSuperInterfaceChain(parent, target); if (sup != null) { sup.setSubType(current); current.setSuperType(sup); return current; } } return null; } protected synchronized HierarchicType _hashMapSuperInterfaceChain(HierarchicType current) { if (_cachedHashMapType == null) { HierarchicType base = current.deepCloneWithoutSubtype(); _doFindSuperInterfaceChain(base, Map.class); _cachedHashMapType = base.getSuperType(); } Hierarchic

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>Type t = _cachedHashMapType.deepCloneWithoutSubtype(); current.setSuperType(t); t.setSubType(current); return current; } protected synchronized HierarchicType _arrayListSuperInterfaceChain(HierarchicType current) { if (_cachedArrayListType == null) { HierarchicType base = current.deepCloneWithoutSubtype(); _doFindSuperInterfaceChain(base, List.class); _cachedArrayListType = base.getSuperType(); } HierarchicType t = _cachedArrayListType.deepCloneWithoutSubtype(); current.setSuperType(t); t.setSubType(current); return current; } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser; import java.lang.reflect.Type; import java.util.*; import com.fasterxml.jackson.annotation.ObjectIdGenerator; import com.fasterxml.jackson.annotation.ObjectIdGenerators; import com.fasterxml.jackson.annotation.ObjectIdResolver; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.annotation.JsonPOJOBuilder; import com.fasterxml.jackson.databind.cfg.DeserializerFactoryConfig; import com.fasterxml.jackson.databind.deser.impl.*; import com.fasterxml.jackson.databind.deser.std.ThrowableDeserializer; import com.fasterxml.jackson.databind.introspect.*; import com.fasterxml.jackson.databind.jsontype.TypeDeserializer; import com.fasterxml.jackson.databind.util.ArrayBuilders; import com.fasterxml.jackson.databind.util.ClassUtil; import com.fasterxml.jackson.databind.util.SimpleBeanPropertyDefinition; /** * Concrete deserializer factory class that adds full Bean deserializer * construction logic using class introspection. * Note that factories specifically do not implement any form of caching: * aside from configuration they are stateless; caching is implemented * by other components. *<p> * Instances of this class are fully immutable as all configuration is * done by using "fluent factories" (methods that construct new factory * instances with different configuration, instead of modifying instance). */ public class BeanDeserializerFactory extends BasicDeserializerFactory implements java.io.Serializable // since 2.1 { private static final long serialVersionUID = 1; /** * Signature of <b>Throwable.initCause</b> method. */ private final static Class<?>[] INIT_CAUSE_PARAMS = new Class<?>[] { Throwable.class }; private final static Class<?>[] NO_VIEWS = new Class<?>[0]; /* /********************************************************** /* Life-cycle /********************************************************** */ /** * Globally shareable thread-safe instance which has no additional custom deserializers * registered */ public final static BeanDeserializerFactory instance = new BeanDeserializerFactory( new DeserializerFactoryConfig()); public BeanDeserializerFactory(DeserializerFactoryConfig config) { super(config); } /** * Method

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> used by module registration functionality, to construct a new bean * deserializer factory * with different configuration settings. */ @Override public DeserializerFactory withConfig(DeserializerFactoryConfig config) { if (_factoryConfig == config) { return this; } /* 22-Nov-2010, tatu: Handling of subtypes is tricky if we do immutable-with-copy-ctor; * and we pretty much have to here either choose between losing subtype instance * when registering additional deserializers, or losing deserializers. * Instead, let's actually just throw an error if this method is called when subtype * has not properly overridden this method; this to indicate problem as soon as possible. */ if (getClass() != BeanDeserializerFactory.class) { throw new IllegalStateException("Subtype of BeanDeserializerFactory ("+getClass().getName() +") has not properly overridden method 'withAdditionalDeserializers': can not instantiate subtype with " +"additional deserializer definitions"); } return new BeanDeserializerFactory(config); } /* /********************************************************** /* DeserializerFactory API implementation /********************************************************** */ /** * Method that {@link DeserializerCache}s call to create a new * deserializer for types other than Collections, Maps, arrays and * enums. */ @Override public JsonDeserializer<Object> createBeanDeserializer(DeserializationContext ctxt, JavaType type, BeanDescription beanDesc) throws JsonMappingException { final DeserializationConfig config = ctxt.getConfig(); // We may also have custom overrides: JsonDeserializer<Object> custom = _findCustomBeanDeserializer(type, config, beanDesc); if (custom != null) { return custom; } /* One more thing to check: do we have an exception type * (Throwable or its sub-classes)? If so, need slightly * different handling. */ if (type.isThrowable()) { return buildThrowableDeserializer(ctxt, type, beanDesc); } /* Or, for abstract types, may have alternate means for resolution * (defaulting, materialization) */ if (type.isAbstract()) { // [JACKSON-41] (v1.6): Let's make it possible to materialize abstract types. JavaType concreteType = materializeAbstract

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> builderConfig); // this may give us more information... if (_factoryConfig.hasDeserializerModifiers()) { for (BeanDeserializerModifier mod : _factoryConfig.deserializerModifiers()) { builder = mod.updateBuilder(config, builderDesc, builder); } } JsonDeserializer<?> deserializer = builder.buildBuilderBased( valueType, buildMethodName); // [JACKSON-440]: may have modifier(s) that wants to modify or replace serializer we just built: if (_factoryConfig.hasDeserializerModifiers()) { for (BeanDeserializerModifier mod : _factoryConfig.deserializerModifiers()) { deserializer = mod.modifyDeserializer(config, builderDesc, deserializer); } } return (JsonDeserializer<Object>) deserializer; } protected void addObjectIdReader(DeserializationContext ctxt, BeanDescription beanDesc, BeanDeserializerBuilder builder) throws JsonMappingException { ObjectIdInfo objectIdInfo = beanDesc.getObjectIdInfo(); if (objectIdInfo == null) { return; } Class<?> implClass = objectIdInfo.getGeneratorType(); JavaType idType; SettableBeanProperty idProp; ObjectIdGenerator<?> gen; ObjectIdResolver resolver = ctxt.objectIdResolverInstance(beanDesc.getClassInfo(), objectIdInfo); // Just one special case: Property-based generator is trickier if (implClass == ObjectIdGenerators.PropertyGenerator.class) { // most special one, needs extra work PropertyName propName = objectIdInfo.getPropertyName(); idProp = builder.findProperty(propName); if (idProp == null) { throw new IllegalArgumentException("Invalid Object Id definition for " +beanDesc.getBeanClass().getName()+": can not find property with name '"+propName+"'"); } idType = idProp.getType(); gen = new PropertyBasedObjectIdGenerator(objectIdInfo.getScope()); } else { JavaType type = ctxt.constructType(implClass); idType = ctxt.getTypeFactory().findTypeParameters(type, ObjectIdGenerator.class)[0]; idProp = null; gen = ctxt.objectIdGeneratorInstance(beanDesc.getClassInfo(), objectIdInfo); } // also: unlike with value deserializers, let's just resolve one we need here JsonDeserializer<?> deser = ctxt.findRootValueDeserializer

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> propertyType = propDef.getSetter().getGenericParameterType(0); prop = constructSettableProperty(ctxt, beanDesc, propDef, propertyType); } else if (propDef.hasField()) { Type propertyType = propDef.getField().getGenericType(); prop = constructSettableProperty(ctxt, beanDesc, propDef, propertyType); } else if (useGettersAsSetters && propDef.hasGetter()) { /* As per [JACKSON-88], may also need to consider getters * for Map/Collection properties; but with lowest precedence */ AnnotatedMethod getter = propDef.getGetter(); // should only consider Collections and Maps, for now? Class<?> rawPropertyType = getter.getRawType(); if (Collection.class.isAssignableFrom(rawPropertyType) || Map.class.isAssignableFrom(rawPropertyType)) { prop = constructSetterlessProperty(ctxt, beanDesc, propDef); } } // 25-Sep-2014, tatu: No point in finding constructor parameters for abstract types // (since they are never used anyway) if (isConcrete && propDef.hasConstructorParameter()) { /* [JACKSON-700] If property is passed via constructor parameter, we must * handle things in special way. Not sure what is the most optimal way... * for now, let's just call a (new) method in builder, which does nothing. */ // but let's call a method just to allow custom builders to be aware... final String name = propDef.getName(); CreatorProperty cprop = null; if (creatorProps != null) { for (SettableBeanProperty cp : creatorProps) { if (name.equals(cp.getName())) { cprop = (CreatorProperty) cp; break; } } } if (cprop == null) { throw ctxt.mappingException("Could not find creator property with name '" +name+"' (in class "+beanDesc.getBeanClass().getName()+")"); } if (prop != null) { cprop = cprop.withFallbackSetter(prop); } prop = cprop; builder.addCreatorProperty(cprop); continue; } if (prop != null) { Class<?>

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std; import java.io.IOException; import java.lang.reflect.Type; import java.util.concurrent.atomic.AtomicReference; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.JavaType; import com.fasterxml.jackson.databind.JsonMappingException; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.JsonSerializable; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.SerializerProvider; import com.fasterxml.jackson.databind.annotation.JacksonStdImpl; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper; import com.fasterxml.jackson.databind.jsonschema.JsonSerializableSchema; import com.fasterxml.jackson.databind.jsontype.TypeSerializer; import com.fasterxml.jackson.databind.node.ObjectNode; import com.fasterxml.jackson.databind.type.TypeFactory; /** * Generic handler for types that implement {@link JsonSerializable}. *<p> * Note: given that this is used for anything that implements * interface, can not be checked for direct class equivalence. */ @JacksonStdImpl @SuppressWarnings("serial") public class SerializableSerializer extends StdSerializer<JsonSerializable> { public final static SerializableSerializer instance = new SerializableSerializer(); // Ugh. Should NOT need this... private final static AtomicReference<ObjectMapper> _mapperReference = new AtomicReference<ObjectMapper>(); protected SerializableSerializer() { super(JsonSerializable.class); } @Override public void serialize(JsonSerializable value, JsonGenerator jgen, SerializerProvider provider) throws IOException { value.serialize(jgen, provider); } @Override public final void serializeWithType(JsonSerializable value, JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer) throws IOException { value.serializeWithType(jgen, provider, typeSer); } @Override @SuppressWarnings("deprecation") public JsonNode getSchema(SerializerProvider provider, Type typeHint) throws JsonMappingException { ObjectNode objectNode = createObjectNode(); String schemaType = "any"; String objectProperties = null; String itemDefinition = null;

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> if (typeHint != null) { Class<?> rawClass = TypeFactory.rawClass(typeHint); if (rawClass.isAnnotationPresent(JsonSerializableSchema.class)) { JsonSerializableSchema schemaInfo = rawClass.getAnnotation(JsonSerializableSchema.class); schemaType = schemaInfo.schemaType(); if (!JsonSerializableSchema.NO_VALUE.equals(schemaInfo.schemaObjectPropertiesDefinition())) { objectProperties = schemaInfo.schemaObjectPropertiesDefinition(); } if (!JsonSerializableSchema.NO_VALUE.equals(schemaInfo.schemaItemDefinition())) { itemDefinition = schemaInfo.schemaItemDefinition(); } } } /* 19-Mar-2012, tatu: geez, this is butt-ugly abonimation of code... * really, really should not require back ref to an ObjectMapper. */ objectNode.put("type", schemaType); if (objectProperties != null) { try { objectNode.put("properties", _getObjectMapper().readTree(objectProperties)); } catch (IOException e) { throw new JsonMappingException("Failed to parse @JsonSerializableSchema.schemaObjectPropertiesDefinition value"); } } if (itemDefinition != null) { try { objectNode.put("items", _getObjectMapper().readTree(itemDefinition)); } catch (IOException e) { throw new JsonMappingException("Failed to parse @JsonSerializableSchema.schemaItemDefinition value"); } } // always optional, no need to specify: //objectNode.put("required", false); return objectNode; } private final static synchronized ObjectMapper _getObjectMapper() { ObjectMapper mapper = _mapperReference.get(); if (mapper == null) { mapper = new ObjectMapper(); _mapperReference.set(mapper); } return mapper; } @Override public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException { visitor.expectAnyFormat(typeHint); } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> /** * Method needed to ensure that {@link ObjectMapper#copy} will work * properly; specifically, that caches are cleared, but settings * will otherwise remain identical; and that no sharing of state * occurs. * * @since 2.5 */ public DefaultSerializerProvider copy() { throw new IllegalStateException("DefaultSerializerProvider sub-class not overriding copy()"); } /* /********************************************************** /* Extended API: methods that ObjectMapper will call /********************************************************** */ /** * Overridable method, used to create a non-blueprint instances from the blueprint. * This is needed to retain state during serialization. */ public abstract DefaultSerializerProvider createInstance(SerializationConfig config, SerializerFactory jsf); /** * The method to be called by {@link ObjectMapper} and {@link ObjectWriter} * for serializing given value, using serializers that * this provider has access to (via caching and/or creating new serializers * as need be). */ public void serializeValue(JsonGenerator gen, Object value) throws IOException { if (value == null) { _serializeNull(gen); return; } Class<?> cls = value.getClass(); // true, since we do want to cache root-level typed serializers (ditto for null property) final JsonSerializer<Object> ser = findTypedValueSerializer(cls, true, null); // Ok: should we wrap result in an additional property ("root name")? final boolean wrap; String rootName = _config.getRootName(); if (rootName == null) { // not explicitly specified // [JACKSON-163] wrap = _config.isEnabled(SerializationFeature.WRAP_ROOT_VALUE); if (wrap) { PropertyName pname = _rootNames.findRootName(value.getClass(), _config); gen.writeStartObject(); gen.writeFieldName(pname.simpleAsEncoded(_config)); } } else if (rootName.length() == 0) { wrap = false; } else { // [JACKSON-764] // empty String means explicitly disabled; non-empty that it is enabled wrap = true; gen.writeStartObject(); gen.writeFieldName(rootName); } try { ser.serialize(value, gen, this

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>); if (wrap) { gen.writeEndObject(); } } catch (IOException ioe) { // As per [JACKSON-99], pass IOException and subtypes as-is throw ioe; } catch (Exception e) { // but wrap RuntimeExceptions, to get path information String msg = e.getMessage(); if (msg == null) { msg = "[no message for "+e.getClass().getName()+"]"; } throw new JsonMappingException(msg, e); } } /** * The method to be called by {@link ObjectMapper} and {@link ObjectWriter} * for serializing given value (assumed to be of specified root type, * instead of runtime type of value), * using serializers that * this provider has access to (via caching and/or creating new serializers * as need be), * * @param rootType Type to use for locating serializer to use, instead of actual * runtime type. Must be actual type, or one of its super types */ public void serializeValue(JsonGenerator gen, Object value, JavaType rootType) throws IOException { if (value == null) { _serializeNull(gen); return; } // Let's ensure types are compatible at this point if (!rootType.getRawClass().isAssignableFrom(value.getClass())) { _reportIncompatibleRootType(value, rootType); } // root value, not reached via property: JsonSerializer<Object> ser = findTypedValueSerializer(rootType, true, null); // Ok: should we wrap result in an additional property ("root name")? final boolean wrap; String rootName = _config.getRootName(); if (rootName == null) { // not explicitly specified // [JACKSON-163] wrap = _config.isEnabled(SerializationFeature.WRAP_ROOT_VALUE); if (wrap) { gen.writeStartObject(); PropertyName pname = _rootNames.findRootName(value.getClass(), _config); gen.writeFieldName(pname.simpleAsEncoded(_config)); } } else if (rootName.length() == 0) { wrap = false; } else { // [JACKSON-764] // empty String means explicitly disabled; non-

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>empty that it is enabled wrap = true; gen.writeStartObject(); gen.writeFieldName(rootName); } try { ser.serialize(value, gen, this); if (wrap) { gen.writeEndObject(); } } catch (IOException ioe) { // no wrapping for IO (and derived) throw ioe; } catch (Exception e) { // but others do need to be, to get path etc String msg = e.getMessage(); if (msg == null) { msg = "[no message for "+e.getClass().getName()+"]"; } throw new JsonMappingException(msg, e); } } /** * The method to be called by {@link ObjectWriter} * for serializing given value (assumed to be of specified root type, * instead of runtime type of value), when it may know specific * {@link JsonSerializer} to use. * * @param rootType Type to use for locating serializer to use, instead of actual * runtime type, if no serializer is passed * @param ser Root Serializer to use, if not null * * @since 2.1 */ public void serializeValue(JsonGenerator gen, Object value, JavaType rootType, JsonSerializer<Object> ser) throws IOException { if (value == null) { _serializeNull(gen); return; } // Let's ensure types are compatible at this point if ((rootType != null) && !rootType.getRawClass().isAssignableFrom(value.getClass())) { _reportIncompatibleRootType(value, rootType); } // root value, not reached via property: if (ser == null) { ser = findTypedValueSerializer(rootType, true, null); } // Ok: should we wrap result in an additional property ("root name")? final boolean wrap; String rootName = _config.getRootName(); if (rootName == null) { // not explicitly specified // [JACKSON-163] wrap = _config.isEnabled(SerializationFeature.WRAP_ROOT_VALUE); if (wrap) { gen.writeStartObject(); PropertyName pname = (rootType == null) ? _rootNames.findRootName(value.getClass(), _config)

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> : _rootNames.findRootName(rootType, _config); gen.writeFieldName(pname.simpleAsEncoded(_config)); } } else if (rootName.length() == 0) { wrap = false; } else { // [JACKSON-764] // empty String means explicitly disabled; non-empty that it is enabled wrap = true; gen.writeStartObject(); gen.writeFieldName(rootName); } try { ser.serialize(value, gen, this); if (wrap) { gen.writeEndObject(); } } catch (IOException ioe) { // no wrapping for IO (and derived) throw ioe; } catch (Exception e) { // but others do need to be, to get path etc String msg = e.getMessage(); if (msg == null) { msg = "[no message for "+e.getClass().getName()+"]"; } throw new JsonMappingException(msg, e); } } /** * Alternate serialization call used for polymorphic types, when {@link TypeSerializer} * is already known, but not actual value serializer. * * @since 2.5 */ public void serializePolymorphic(JsonGenerator gen, Object value, TypeSerializer typeSer) throws IOException { if (value == null) { _serializeNull(gen); return; } final Class<?> type = value.getClass(); JsonSerializer<Object> ser = findValueSerializer(type, null); final boolean wrap; String rootName = _config.getRootName(); if (rootName == null) { wrap = _config.isEnabled(SerializationFeature.WRAP_ROOT_VALUE); if (wrap) { gen.writeStartObject(); PropertyName pname = _rootNames.findRootName(type, _config); gen.writeFieldName(pname.simpleAsEncoded(_config)); } } else if (rootName.length() == 0) { wrap = false; } else { wrap = true; gen.writeStartObject(); gen.writeFieldName(rootName); } try { ser.serializeWithType(value, gen, this, typeSer); if (wrap) { gen.writeEndObject(); } } catch

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> (IOException ioe) { // no wrapping for IO (and derived) throw ioe; } catch (Exception e) { // but others do need to be, to get path etc String msg = e.getMessage(); if (msg == null) { msg = "[no message for "+e.getClass().getName()+"]"; } throw new JsonMappingException(msg, e); } } /** * Helper method called when root value to serialize is null * * @since 2.3 */ protected void _serializeNull(JsonGenerator gen) throws IOException { JsonSerializer<Object> ser = getDefaultNullValueSerializer(); try { ser.serialize(null, gen, this); } catch (IOException ioe) { // no wrapping for IO (and derived) throw ioe; } catch (Exception e) { // but others do need to be, to get path etc String msg = e.getMessage(); if (msg == null) { msg = "[no message for "+e.getClass().getName()+"]"; } throw new JsonMappingException(msg, e); } } /** * The method to be called by {@link ObjectMapper} and {@link ObjectWriter} * to generate <a href="http://json-schema.org/">JSON schema</a> for * given type. * * @param type The type for which to generate schema */ @SuppressWarnings("deprecation") public com.fasterxml.jackson.databind.jsonschema.JsonSchema generateJsonSchema(Class<?> type) throws JsonMappingException { if (type == null) { throw new IllegalArgumentException("A class must be provided"); } /* no need for embedded type information for JSON schema generation (all * type information it needs is accessible via "untyped" serializer) */ JsonSerializer<Object> ser = findValueSerializer(type, null); JsonNode schemaNode = (ser instanceof SchemaAware) ? ((SchemaAware) ser).getSchema(this, null) : com.fasterxml.jackson.databind.jsonschema.JsonSchema.getDefaultSchemaNode(); if (!(schemaNode instanceof ObjectNode)) { throw new IllegalArgumentException("Class " + type.getName() +" would not be serialized as a JSON object and therefore has no schema"); } return new com.fasterxml.jackson.databind.json

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> /********************************************************** */ @Override public JsonSerializer<Object> serializerInstance(Annotated annotated, Object serDef) throws JsonMappingException { if (serDef == null) { return null; } JsonSerializer<?> ser; if (serDef instanceof JsonSerializer) { ser = (JsonSerializer<?>) serDef; } else { /* Alas, there's no way to force return type of "either class * X or Y" -- need to throw an exception after the fact */ if (!(serDef instanceof Class)) { throw new IllegalStateException("AnnotationIntrospector returned serializer definition of type " +serDef.getClass().getName()+"; expected type JsonSerializer or Class<JsonSerializer> instead"); } Class<?> serClass = (Class<?>)serDef; // there are some known "no class" markers to consider too: if (serClass == JsonSerializer.None.class || ClassUtil.isBogusClass(serClass)) { return null; } if (!JsonSerializer.class.isAssignableFrom(serClass)) { throw new IllegalStateException("AnnotationIntrospector returned Class " +serClass.getName()+"; expected Class<JsonSerializer>"); } HandlerInstantiator hi = _config.getHandlerInstantiator(); ser = (hi == null) ? null : hi.serializerInstance(_config, annotated, serClass); if (ser == null) { ser = (JsonSerializer<?>) ClassUtil.createInstance(serClass, _config.canOverrideAccessModifiers()); } } return (JsonSerializer<Object>) _handleResolvable(ser); } /* /********************************************************** /* Helper classes /********************************************************** */ /** * Concrete implementation that defines factory method(s), * defined as final. */ public final static class Impl extends DefaultSerializerProvider { private static final long serialVersionUID = 1L; public Impl() { super(); } public Impl(Impl src) { super(src); } protected Impl(SerializerProvider src, SerializationConfig config,SerializerFactory f) { super(src, config, f); } @Override public DefaultSerializerProvider copy() { if (getClass() != Impl.class) { return super.copy(); } return new Impl(this); } @Override public Impl

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>.introspect(type); // Ok, so: can we find T(String) constructor? Constructor<?> ctor = beanDesc.findSingleArgConstructor(String.class); if (ctor != null) { if (config.canOverrideAccessModifiers()) { ClassUtil.checkAndFixAccess(ctor); } return new StdKeyDeserializer.StringCtorKeyDeserializer(ctor); } /* or if not, "static T valueOf(String)" (or equivalent marked * with @JsonCreator annotation?) */ Method m = beanDesc.findFactoryMethod(String.class); if (m != null){ if (config.canOverrideAccessModifiers()) { ClassUtil.checkAndFixAccess(m); } return new StdKeyDeserializer.StringFactoryKeyDeserializer(m); } // nope, no such luck... return null; } /* /********************************************************** /* KeyDeserializers implementation /********************************************************** */ @Override public KeyDeserializer findKeyDeserializer(JavaType type, DeserializationConfig config, BeanDescription beanDesc) throws JsonMappingException { Class<?> raw = type.getRawClass(); // 23-Apr-2013, tatu: Map primitive types, just in case one was given if (raw.isPrimitive()) { raw = ClassUtil.wrapperType(raw); } return StdKeyDeserializer.forType(raw); } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> // If not, do we have a pattern? TimeZone tz = format.getTimeZone(); if (format.hasPattern()) { String pattern = format.getPattern(); final Locale loc = format.hasLocale() ? format.getLocale() : prov.getLocale(); SimpleDateFormat df = new SimpleDateFormat(pattern, loc); if (tz == null) { tz = prov.getTimeZone(); } df.setTimeZone(tz); return withFormat(asNumber, df); } // If not, do we at least have a custom timezone? if (tz != null) { DateFormat df = prov.getConfig().getDateFormat(); // one shortcut: with our custom format, can simplify handling a bit if (df.getClass() == StdDateFormat.class) { final Locale loc = format.hasLocale() ? format.getLocale() : prov.getLocale(); df = StdDateFormat.getISO8601Format(tz, loc); } else { // otherwise need to clone, re-set timezone: df = (DateFormat) df.clone(); df.setTimeZone(tz); } return withFormat(asNumber, df); } } } return this; } /* /********************************************************** /* Accessors /********************************************************** */ @Override public boolean isEmpty(T value) { // let's assume "null date" (timestamp 0) qualifies for empty return (value == null) || (_timestamp(value) == 0L); } protected abstract long _timestamp(T value); @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) { //todo: (ryan) add a format for the date in the schema? return createSchemaNode(_asTimestamp(provider) ? "number" : "string", true); } @Override public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException { _acceptJsonFormatVisitor(visitor, typeHint, _asTimestamp(visitor.getProvider())); } /* /********************************************************** /* Actual serialization /********************************************************** */ @Override public abstract void serialize(T value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException; /* /********************************************************** /* Helper methods /

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std; import java.io.IOException; import java.text.DateFormat; import java.util.*; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.annotation.JacksonStdImpl; /** * For efficiency, we will serialize Dates as longs, instead of * potentially more readable Strings. */ @JacksonStdImpl @SuppressWarnings("serial") public class DateSerializer extends DateTimeSerializerBase<Date> { /** * Default instance that is used when no contextual configuration * is needed. */ public static final DateSerializer instance = new DateSerializer(); public DateSerializer() { this(null, null); } public DateSerializer(Boolean useTimestamp, DateFormat customFormat) { super(Date.class, useTimestamp, customFormat); } @Override public DateSerializer withFormat(Boolean timestamp, DateFormat customFormat) { return new DateSerializer(timestamp, customFormat); } @Override protected long _timestamp(Date value) { return (value == null) ? 0L : value.getTime(); } @Override public void serialize(Date value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { if (_asTimestamp(provider)) { jgen.writeNumber(_timestamp(value)); } else if (_customFormat != null) { // 21-Feb-2011, tatu: not optimal, but better than alternatives: synchronized (_customFormat) { jgen.writeString(_customFormat.format(value)); } } else { provider.defaultSerializeDateValue(value, jgen); } } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> @Override public int getParameterCount() { return getRawParameterTypes().length; } public String getFullName() { return getDeclaringClass().getName() + "#" + getName() + "(" +getParameterCount()+" params)"; } public Class<?>[] getRawParameterTypes() { if (_paramClasses == null) { _paramClasses = _method.getParameterTypes(); } return _paramClasses; } public Type[] getGenericParameterTypes() { return _method.getGenericParameterTypes(); } @Override public Class<?> getRawParameterType(int index) { Class<?>[] types = getRawParameterTypes(); return (index >= types.length) ? null : types[index]; } @Override public Type getGenericParameterType(int index) { Type[] types = _method.getGenericParameterTypes(); return (index >= types.length) ? null : types[index]; } public Class<?> getRawReturnType() { return _method.getReturnType(); } public Type getGenericReturnType() { return _method.getGenericReturnType(); } /** * Helper method that can be used to check whether method returns * a value or not; if return type declared as <code>void</code>, returns * false, otherwise true * * @since 2.4 */ public boolean hasReturnType() { Class<?> rt = getRawReturnType(); return (rt != Void.TYPE && rt != Void.class); } /* /******************************************************** /* Other /******************************************************** */ @Override public String toString() { return "[method "+getFullName()+"]"; } @Override public int hashCode() { return _method.getName().hashCode(); } @Override public boolean equals(Object o) { if (o == this) return true; if (o == null || o.getClass() != getClass()) return false; return ((AnnotatedMethod) o)._method == _method; } /* /********************************************************** /* JDK serialization handling /********************************************************** */ Object writeReplace() { return new AnnotatedMethod(new Serialization(_method)); } Object readResolve() { Class<?> clazz = _serialization.clazz; try { Method m = clazz.getDeclaredMethod(_serialization.name

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser.std; import java.io.IOException; import java.util.*; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.deser.ContextualDeserializer; import com.fasterxml.jackson.databind.jsontype.TypeDeserializer; /** * Standard deserializer for {@link EnumSet}s. * <p> * Note: casting within this class is all messed up -- just could not figure out a way * to properly deal with recursive definition of "EnumSet<K extends Enum<K>, V> */ @SuppressWarnings("rawtypes") public class EnumSetDeserializer extends StdDeserializer<EnumSet<?>> implements ContextualDeserializer { private static final long serialVersionUID = 1L; // since 2.5 protected final JavaType _enumType; protected final Class<Enum> _enumClass; protected JsonDeserializer<Enum<?>> _enumDeserializer; /* /********************************************************** /* Life-cycle /********************************************************** */ @SuppressWarnings("unchecked" ) public EnumSetDeserializer(JavaType enumType, JsonDeserializer<?> deser) { super(EnumSet.class); _enumType = enumType; _enumClass = (Class<Enum>) enumType.getRawClass(); _enumDeserializer = (JsonDeserializer<Enum<?>>) deser; } public EnumSetDeserializer withDeserializer(JsonDeserializer<?> deser) { if (_enumDeserializer == deser) { return this; } return new EnumSetDeserializer(_enumType, deser); } /** * Because of costs associated with constructing Enum resolvers, * let's cache instances by default. */ @Override public boolean isCachable() { // One caveat: content deserializer should prevent caching if (_enumType.getValueHandler() != null) { return false; } return true; } @Override public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException { JsonDeserializer<?> deser = _enumDeserializer; if (deser == null) { deser = ctxt.findContextualValueDeserializer(_enumType, property); } else { // if directly assigned, probably not yet contextual, so:

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> deser = ctxt.handleSecondaryContextualization(deser, property, _enumType); } return withDeserializer(deser); } /* /********************************************************** /* JsonDeserializer API /********************************************************** */ @SuppressWarnings("unchecked") @Override public EnumSet<?> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { // Ok: must point to START_ARRAY (or equivalent) if (!jp.isExpectedStartArrayToken()) { throw ctxt.mappingException(EnumSet.class); } EnumSet result = constructSet(); JsonToken t; try { while ((t = jp.nextToken()) != JsonToken.END_ARRAY) { /* What to do with nulls? Fail or ignore? Fail, for now * (note: would fail if we passed it to EnumDeserializer, too, * but in general nulls should never be passed to non-container * deserializers) */ if (t == JsonToken.VALUE_NULL) { throw ctxt.mappingException(_enumClass); } Enum<?> value = _enumDeserializer.deserialize(jp, ctxt); /* 24-Mar-2012, tatu: As per [JACKSON-810], may actually get nulls; * but EnumSets don't allow nulls so need to skip. */ if (value != null) { result.add(value); } } } catch (Exception e) { throw JsonMappingException.wrapWithPath(e, result, result.size()); } return result; } @Override public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException, JsonProcessingException { return typeDeserializer.deserializeTypedFromArray(jp, ctxt); } @SuppressWarnings("unchecked") private EnumSet constructSet() { // superbly ugly... but apparently necessary return EnumSet.noneOf(_enumClass); } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> Default value indicates that * property should only be written if specified attribute has a non-null * value. */ public JsonInclude.Include include() default JsonInclude.Include.NON_NULL; /** * Metadata about property, similar to * {@link com.fasterxml.jackson.annotation.JsonProperty#required()}. */ public boolean required() default false; } /** * Definition of a single general virtual property. */ public @interface Prop { /** * Actual implementation class (a subtype of {@link VirtualBeanPropertyWriter}) * of the property to instantiate (using the no-argument default constructor). */ public Class<? extends VirtualBeanPropertyWriter> value(); /** * Name of the property to possibly use for serializing (although implementation * may choose to not use this information). */ public String name() default ""; /** * Optional namespace to use along with {@link #name}; * only relevant for data formats that use namespaces (like XML). */ public String namespace() default ""; /** * When to include value of the property. Default value indicates that * property should only be written if specified attribute has a non-null * value. As with other properties, actual property implementation may or may * not choose to use this inclusion information. */ public JsonInclude.Include include() default JsonInclude.Include.NON_NULL; /** * Metadata about property, similar to * {@link com.fasterxml.jackson.annotation.JsonProperty#required()}. */ public boolean required() default false; /** * Nominal type of the property. Passed as type information for related * virtual objects, and may (or may not be) used by implementation * for choosing serializer to use. */ public Class<?> type() default Object.class; } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std; import java.io.IOException; import java.lang.reflect.Type; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.JavaType; import com.fasterxml.jackson.databind.JsonMappingException; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.SerializerProvider; import com.fasterxml.jackson.databind.annotation.JacksonStdImpl; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper; /** * Serializer used for primitive boolean, as well as java.util.Boolean * wrapper type. *<p> * Since this is one of "native" types, no type information is ever * included on serialization (unlike for most scalar types as of 1.5) */ @JacksonStdImpl public final class BooleanSerializer extends NonTypedScalarSerializerBase<Boolean> { private static final long serialVersionUID = 1L; /** * Whether type serialized is primitive (boolean) or wrapper * (java.lang.Boolean); if true, former, if false, latter. */ protected final boolean _forPrimitive; public BooleanSerializer(boolean forPrimitive) { super(Boolean.class); _forPrimitive = forPrimitive; } @Override public void serialize(Boolean value, JsonGenerator jgen, SerializerProvider provider) throws IOException { jgen.writeBoolean(value.booleanValue()); } @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) { return createSchemaNode("boolean", !_forPrimitive); } @Override public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException { if (visitor != null) { visitor.expectBooleanFormat(typeHint); } } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>) { // let's invalidate the read-only copy, too, to get it updated _readOnlyMap = null; } /* Finally: some serializers want to do post-processing, after * getting registered (to handle cyclic deps). */ /* 14-May-2011, tatu: As per [JACKSON-570], resolving needs to be done * in synchronized manner; this because while we do need to register * instance first, we also must keep lock until resolution is complete */ if (ser instanceof ResolvableSerializer) { ((ResolvableSerializer) ser).resolve(provider); } } } public void addAndResolveNonTypedSerializer(JavaType type, JsonSerializer<Object> ser, SerializerProvider provider) throws JsonMappingException { synchronized (this) { if (_sharedMap.put(new TypeKey(type, false), ser) == null) { // let's invalidate the read-only copy, too, to get it updated _readOnlyMap = null; } /* Finally: some serializers want to do post-processing, after * getting registered (to handle cyclic deps). */ /* 14-May-2011, tatu: As per [JACKSON-570], resolving needs to be done * in synchronized manner; this because while we do need to register * instance first, we also must keep lock until resolution is complete */ if (ser instanceof ResolvableSerializer) { ((ResolvableSerializer) ser).resolve(provider); } } } /** * Method called by StdSerializerProvider#flushCachedSerializers() to * clear all cached serializers */ public synchronized void flush() { _sharedMap.clear(); } /* /************************************************************** /* Helper class(es) /************************************************************** */ /** * Key that offers two "modes"; one with raw class, as used for * cases were raw class type is available (for example, when using * runtime type); and one with full generics-including. */ public final static class TypeKey { protected int _hashCode; protected Class<?> _class; protected JavaType _type; /** * Indicator of whether serializer stored has a type serializer * wrapper around it

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> or not; if not, it is "untyped" serializer; * if it has, it is "typed" */ protected boolean _isTyped; public TypeKey(Class<?> key, boolean typed) { _class = key; _type = null; _isTyped = typed; _hashCode = hash(key, typed); } public TypeKey(JavaType key, boolean typed) { _type = key; _class = null; _isTyped = typed; _hashCode = hash(key, typed); } private final static int hash(Class<?> cls, boolean typed) { int hash = cls.getName().hashCode(); if (typed) { ++hash; } return hash; } private final static int hash(JavaType type, boolean typed) { int hash = type.hashCode() - 1; if (typed) { --hash; } return hash; } public void resetTyped(Class<?> cls) { _type = null; _class = cls; _isTyped = true; _hashCode = hash(cls, true); } public void resetUntyped(Class<?> cls) { _type = null; _class = cls; _isTyped = false; _hashCode = hash(cls, false); } public void resetTyped(JavaType type) { _type = type; _class = null; _isTyped = true; _hashCode = hash(type, true); } public void resetUntyped(JavaType type) { _type = type; _class = null; _isTyped = false; _hashCode = hash(type, false); } @Override public final int hashCode() { return _hashCode; } @Override public final String toString() { if (_class != null) { return "{class: "+_class.getName()+", typed? "+_isTyped+"}"; } return "{type: "+_type+", typed? "+_isTyped+"}"; } // note: we assume key is never used for anything other than as map key, so: @Override public final boolean equals(Object o) { if (o == null) return false; if (o == this) return true; if

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> (o.getClass() != getClass()) { return false; } TypeKey other = (TypeKey) o; if (other._isTyped == _isTyped) { if (_class != null) { return other._class == _class; } return _type.equals(other._type); } return false; } } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>additional == null) { throw new IllegalArgumentException("Can not pass null Serializers"); } Serializers[] all = ArrayBuilders.insertInListNoDup(_additionalKeySerializers, additional); return new SerializerFactoryConfig(_additionalSerializers, all, _modifiers); } public SerializerFactoryConfig withSerializerModifier(BeanSerializerModifier modifier) { if (modifier == null) { throw new IllegalArgumentException("Can not pass null modifier"); } BeanSerializerModifier[] modifiers = ArrayBuilders.insertInListNoDup(_modifiers, modifier); return new SerializerFactoryConfig(_additionalSerializers, _additionalKeySerializers, modifiers); } public boolean hasSerializers() { return _additionalSerializers.length > 0; } public boolean hasKeySerializers() { return _additionalKeySerializers.length > 0; } public boolean hasSerializerModifiers() { return _modifiers.length > 0; } public Iterable<Serializers> serializers() { return new ArrayIterator<Serializers>(_additionalSerializers); } public Iterable<Serializers> keySerializers() { return new ArrayIterator<Serializers>(_additionalKeySerializers); } public Iterable<BeanSerializerModifier> serializerModifiers() { return new ArrayIterator<BeanSerializerModifier>(_modifiers); } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> not instances */ protected final static HashMap<String, Class<? extends JsonSerializer<?>>> _concreteLazy = new HashMap<String, Class<? extends JsonSerializer<?>>>(); static { /* String and string-like types (note: date types explicitly * not included -- can use either textual or numeric serialization) */ _concrete.put(String.class.getName(), new StringSerializer()); final ToStringSerializer sls = ToStringSerializer.instance; _concrete.put(StringBuffer.class.getName(), sls); _concrete.put(StringBuilder.class.getName(), sls); _concrete.put(Character.class.getName(), sls); _concrete.put(Character.TYPE.getName(), sls); // Primitives/wrappers for primitives (primitives needed for Beans) NumberSerializers.addAll(_concrete); _concrete.put(Boolean.TYPE.getName(), new BooleanSerializer(true)); _concrete.put(Boolean.class.getName(), new BooleanSerializer(false)); // Other numbers, more complicated _concrete.put(BigInteger.class.getName(), new NumberSerializer(BigInteger.class)); _concrete.put(BigDecimal.class.getName(),new NumberSerializer(BigDecimal.class)); // Other discrete non-container types: // First, Date/Time zoo: _concrete.put(Calendar.class.getName(), CalendarSerializer.instance); DateSerializer dateSer = DateSerializer.instance; _concrete.put(java.util.Date.class.getName(), dateSer); // note: timestamps are very similar to java.util.Date, thus serialized as such _concrete.put(java.sql.Timestamp.class.getName(), dateSer); // leave some of less commonly used ones as lazy, no point in proactive construction _concreteLazy.put(java.sql.Date.class.getName(), SqlDateSerializer.class); _concreteLazy.put(java.sql.Time.class.getName(), SqlTimeSerializer.class); // And then other standard non-structured JDK types for (Map.Entry<Class<?>,Object> en : StdJdkSerializers.all()) { Object value = en.getValue(); if (value instanceof JsonSerializer<?>) { _concrete.put(en.getKey().getName(), (JsonSerializer<?>) value); } else if (value instanceof Class<?

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>>) { @SuppressWarnings("unchecked") Class<? extends JsonSerializer<?>> cls = (Class<? extends JsonSerializer<?>>) value; _concreteLazy.put(en.getKey().getName(), cls); } else { // should never happen, but: throw new IllegalStateException("Internal error: unrecognized value of type "+en.getClass().getName()); } } // Jackson-specific type(s) // (Q: can this ever be sub-classed?) _concreteLazy.put(TokenBuffer.class.getName(), TokenBufferSerializer.class); } /* /********************************************************** /* Configuration /********************************************************** */ /** * Configuration settings for this factory; immutable instance (just like this * factory), new version created via copy-constructor (fluent-style) */ protected final SerializerFactoryConfig _factoryConfig; /* /********************************************************** /* Life cycle /********************************************************** */ /** * We will provide default constructor to allow sub-classing, * but make it protected so that no non-singleton instances of * the class will be instantiated. */ protected BasicSerializerFactory(SerializerFactoryConfig config) { _factoryConfig = (config == null) ? new SerializerFactoryConfig() : config; } /** * Method for getting current {@link SerializerFactoryConfig}. *<p> * Note that since instances are immutable, you can NOT change settings * by accessing an instance and calling methods: this will simply create * new instance of config object. */ public SerializerFactoryConfig getFactoryConfig() { return _factoryConfig; } /** * Method used for creating a new instance of this factory, but with different * configuration. Reason for specifying factory method (instead of plain constructor) * is to allow proper sub-classing of factories. *<p> * Note that custom sub-classes generally <b>must override</b> implementation * of this method, as it usually requires instantiating a new instance of * factory type. Check out javadocs for * {@link com.fasterxml.jackson.databind.ser.BeanSerializerFactory} for more details. */ public abstract SerializerFactory withConfig(SerializerFactoryConfig config); /** * Convenience method for creating a new factory instance with an additional * serializer provider. */ @Override public final SerializerFactory withAdditionalSerial

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>izers(Serializers additional) { return withConfig(_factoryConfig.withAdditionalSerializers(additional)); } /** * Convenience method for creating a new factory instance with an additional * key serializer provider. */ @Override public final SerializerFactory withAdditionalKeySerializers(Serializers additional) { return withConfig(_factoryConfig.withAdditionalKeySerializers(additional)); } /** * Convenience method for creating a new factory instance with additional bean * serializer modifier. */ @Override public final SerializerFactory withSerializerModifier(BeanSerializerModifier modifier) { return withConfig(_factoryConfig.withSerializerModifier(modifier)); } /* /********************************************************** /* SerializerFactory impl /********************************************************** */ // Implemented by sub-classes @Override public abstract JsonSerializer<Object> createSerializer(SerializerProvider prov, JavaType type) throws JsonMappingException; @Override @SuppressWarnings("unchecked") public JsonSerializer<Object> createKeySerializer(SerializationConfig config, JavaType keyType, JsonSerializer<Object> defaultImpl) { // We should not need any member method info; at most class annotations for Map type // ... at least, not here. BeanDescription beanDesc = config.introspectClassAnnotations(keyType.getRawClass()); JsonSerializer<?> ser = null; // Minor optimization: to avoid constructing beanDesc, bail out if none registered if (_factoryConfig.hasKeySerializers()) { // Only thing we have here are module-provided key serializers: for (Serializers serializers : _factoryConfig.keySerializers()) { ser = serializers.findSerializer(config, keyType, beanDesc); if (ser != null) { break; } } } if (ser == null) { ser = defaultImpl; if (ser == null) { ser = StdKeySerializers.getStdKeySerializer(config, keyType.getRawClass(), false); // As per [databind#47], also need to support @JsonValue if (ser == null) { beanDesc = config.introspect(keyType); AnnotatedMethod am = beanDesc.findJsonValueMethod(); if (am != null) { final Class<?> rawType = am.getRawReturnType(); JsonSerializer<?> delegate = StdKeySerializers.getStdKeySerializer(config, rawType,

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> { Class<?> raw = type.getRawClass(); String clsName = raw.getName(); JsonSerializer<?> ser = _concrete.get(clsName); if (ser == null) { Class<? extends JsonSerializer<?>> serClass = _concreteLazy.get(clsName); if (serClass != null) { try { return serClass.newInstance(); } catch (Exception e) { throw new IllegalStateException("Failed to instantiate standard serializer (of type "+serClass.getName()+"): " +e.getMessage(), e); } } } return ser; } /** * Method called to see if one of primary per-class annotations * (or related, like implementing of {@link JsonSerializable}) * determines the serializer to use. *<p> * Currently handles things like: *<ul> * <li>If type implements {@link JsonSerializable}, use that * </li> * <li>If type has {@link com.fasterxml.jackson.annotation.JsonValue} annotation (or equivalent), build serializer * based on that property * </li> *</ul> * * @since 2.0 */ protected final JsonSerializer<?> findSerializerByAnnotations(SerializerProvider prov, JavaType type, BeanDescription beanDesc) throws JsonMappingException { Class<?> raw = type.getRawClass(); // First: JsonSerializable? if (JsonSerializable.class.isAssignableFrom(raw)) { return SerializableSerializer.instance; } // Second: @JsonValue for any type AnnotatedMethod valueMethod = beanDesc.findJsonValueMethod(); if (valueMethod != null) { Method m = valueMethod.getAnnotated(); if (prov.canOverrideAccessModifiers()) { ClassUtil.checkAndFixAccess(m); } JsonSerializer<Object> ser = findSerializerFromAnnotation(prov, valueMethod); return new JsonValueSerializer(m, ser); } // No well-known annotations... return null; } /** * Method for checking if we can determine serializer to use based on set of * known primary types, checking for set of known base types (exact matches * having been compared against with <code>findSerializerByLookup</code>). * This does not include "secondary" interfaces, but * mostly concrete or abstract base

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> classes. */ protected final JsonSerializer<?> findSerializerByPrimaryType(SerializerProvider prov, JavaType type, BeanDescription beanDesc, boolean staticTyping) throws JsonMappingException { Class<?> raw = type.getRawClass(); // Then check for optional/external serializers [JACKSON-386] JsonSerializer<?> ser = findOptionalStdSerializer(prov, type, beanDesc, staticTyping); if (ser != null) { return ser; } if (Calendar.class.isAssignableFrom(raw)) { return CalendarSerializer.instance; } if (java.util.Date.class.isAssignableFrom(raw)) { return DateSerializer.instance; } if (Map.Entry.class.isAssignableFrom(raw)) { JavaType kt, vt; JavaType[] params = prov.getTypeFactory().findTypeParameters(type, Map.Entry.class); if (params == null || params.length != 2) { // assume that if we don't get 2, they are wrong... kt = vt = TypeFactory.unknownType(); } else { kt = params[0]; vt = params[1]; } return buildMapEntrySerializer(prov.getConfig(), type, beanDesc, staticTyping, kt, vt); } if (ByteBuffer.class.isAssignableFrom(raw)) { return new ByteBufferSerializer(); } if (InetAddress.class.isAssignableFrom(raw)) { return new InetAddressSerializer(); } if (InetSocketAddress.class.isAssignableFrom(raw)) { return new InetSocketAddressSerializer(); } if (TimeZone.class.isAssignableFrom(raw)) { return new TimeZoneSerializer(); } if (java.nio.charset.Charset.class.isAssignableFrom(raw)) { return ToStringSerializer.instance; } if (Number.class.isAssignableFrom(raw)) { // 21-May-2014, tatu: Couple of alternatives actually JsonFormat.Value format = beanDesc.findExpectedFormat(null); if (format != null) { switch (format.getShape()) { case STRING: return ToStringSerializer.instance; case OBJECT: // need to bail out to let it be serialized as POJO case ARRAY: // or, I guess ARRAY; otherwise no point in speculating return null; default:

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> } } return NumberSerializer.instance; } if (Enum.class.isAssignableFrom(raw)) { return buildEnumSerializer(prov.getConfig(), type, beanDesc); } return null; } /** * Overridable method called after checking all other types. * * @since 2.2 */ protected JsonSerializer<?> findOptionalStdSerializer(SerializerProvider prov, JavaType type, BeanDescription beanDesc, boolean staticTyping) throws JsonMappingException { return OptionalHandlerFactory.instance.findSerializer(prov.getConfig(), type, beanDesc); } /** * Reflection-based serialized find method, which checks if * given class implements one of recognized "add-on" interfaces. * Add-on here means a role that is usually or can be a secondary * trait: for example, * bean classes may implement {@link Iterable}, but their main * function is usually something else. The reason for */ protected final JsonSerializer<?> findSerializerByAddonType(SerializationConfig config, JavaType javaType, BeanDescription beanDesc, boolean staticTyping) throws JsonMappingException { Class<?> type = javaType.getRawClass(); if (Iterator.class.isAssignableFrom(type)) { JavaType[] params = config.getTypeFactory().findTypeParameters(javaType, Iterator.class); JavaType vt = (params == null || params.length != 1) ? TypeFactory.unknownType() : params[0]; return buildIteratorSerializer(config, javaType, beanDesc, staticTyping, vt); } if (Iterable.class.isAssignableFrom(type)) { JavaType[] params = config.getTypeFactory().findTypeParameters(javaType, Iterable.class); JavaType vt = (params == null || params.length != 1) ? TypeFactory.unknownType() : params[0]; return buildIterableSerializer(config, javaType, beanDesc, staticTyping, vt); } if (CharSequence.class.isAssignableFrom(type)) { return ToStringSerializer.instance; } return null; } /** * Helper method called to check if a class or method * has an annotation * (@link com.fasterxml.jackson.databind.annotation.JsonSerialize#using) * that tells the class to use for serialization. * Returns null if

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>.useStaticType()) { if (!type.isContainerType() || type.getContentType().getRawClass() != Object.class) { staticTyping = true; } } // Let's see what we can learn about element/content/value type, type serializer for it: JavaType elementType = type.getContentType(); TypeSerializer elementTypeSerializer = createTypeSerializer(config, elementType); // if elements have type serializer, can not force static typing: if (elementTypeSerializer != null) { staticTyping = false; } JsonSerializer<Object> elementValueSerializer = _findContentSerializer(prov, beanDesc.getClassInfo()); if (type.isMapLikeType()) { // implements java.util.Map MapLikeType mlt = (MapLikeType) type; /* 29-Sep-2012, tatu: This is actually too early to (try to) find * key serializer from property annotations, and can lead to caching * issues (see [Issue#75]). Instead, must be done from 'createContextual()' call. * But we do need to check class annotations. */ JsonSerializer<Object> keySerializer = _findKeySerializer(prov, beanDesc.getClassInfo()); if (mlt.isTrueMapType()) { return buildMapSerializer(config, (MapType) mlt, beanDesc, staticTyping, keySerializer, elementTypeSerializer, elementValueSerializer); } // Only custom serializers may be available: for (Serializers serializers : customSerializers()) { MapLikeType mlType = (MapLikeType) type; JsonSerializer<?> ser = serializers.findMapLikeSerializer(config, mlType, beanDesc, keySerializer, elementTypeSerializer, elementValueSerializer); if (ser != null) { // [Issue#120]: Allow post-processing if (_factoryConfig.hasSerializerModifiers()) { for (BeanSerializerModifier mod : _factoryConfig.serializerModifiers()) { ser = mod.modifyMapLikeSerializer(config, mlType, beanDesc, ser); } } return ser; } } return null; } if (type.isCollectionLikeType()) { CollectionLikeType clt = (CollectionLikeType) type; if (clt.isTrueCollection

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>Type()) { return buildCollectionSerializer(config, (CollectionType) clt, beanDesc, staticTyping, elementTypeSerializer, elementValueSerializer); } CollectionLikeType clType = (CollectionLikeType) type; // Only custom variants for this: for (Serializers serializers : customSerializers()) { JsonSerializer<?> ser = serializers.findCollectionLikeSerializer(config, clType, beanDesc, elementTypeSerializer, elementValueSerializer); if (ser != null) { // [Issue#120]: Allow post-processing if (_factoryConfig.hasSerializerModifiers()) { for (BeanSerializerModifier mod : _factoryConfig.serializerModifiers()) { ser = mod.modifyCollectionLikeSerializer(config, clType, beanDesc, ser); } } return ser; } } // fall through either way (whether shape dictates serialization as POJO or not) return null; } if (type.isArrayType()) { return buildArraySerializer(config, (ArrayType) type, beanDesc, staticTyping, elementTypeSerializer, elementValueSerializer); } return null; } /** * Helper method that handles configuration details when constructing serializers for * {@link java.util.List} types that support efficient by-index access * * @since 2.1 */ protected JsonSerializer<?> buildCollectionSerializer(SerializationConfig config, CollectionType type, BeanDescription beanDesc, boolean staticTyping, TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer) throws JsonMappingException { JsonSerializer<?> ser = null; // Module-provided custom collection serializers? for (Serializers serializers : customSerializers()) { ser = serializers.findCollectionSerializer(config, type, beanDesc, elementTypeSerializer, elementValueSerializer); if (ser != null) { break; } } if (ser == null) { // We may also want to use serialize Collections "as beans", if (and only if) // this is specified with `@JsonFormat(shape=Object)` JsonFormat.Value format = beanDesc.findExpectedFormat(null); if (format != null && format.getShape() == JsonFormat.Shape.OBJECT) { return null; } Class<?> raw = type.getRawClass(); if (Enum

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>Set.class.isAssignableFrom(raw)) { // this may or may not be available (Class doesn't; type of field/method does) JavaType enumType = type.getContentType(); // and even if nominally there is something, only use if it really is enum if (!enumType.isEnumType()) { enumType = null; } ser = buildEnumSetSerializer(enumType); } else { Class<?> elementRaw = type.getContentType().getRawClass(); if (isIndexedList(raw)) { if (elementRaw == String.class) { // [JACKSON-829] Must NOT use if we have custom serializer if (elementValueSerializer == null || ClassUtil.isJacksonStdImpl(elementValueSerializer)) { ser = IndexedStringListSerializer.instance; } } else { ser = buildIndexedListSerializer(type.getContentType(), staticTyping, elementTypeSerializer, elementValueSerializer); } } else if (elementRaw == String.class) { // [JACKSON-829] Must NOT use if we have custom serializer if (elementValueSerializer == null || ClassUtil.isJacksonStdImpl(elementValueSerializer)) { ser = StringCollectionSerializer.instance; } } if (ser == null) { ser = buildCollectionSerializer(type.getContentType(), staticTyping, elementTypeSerializer, elementValueSerializer); } } } // [Issue#120]: Allow post-processing if (_factoryConfig.hasSerializerModifiers()) { for (BeanSerializerModifier mod : _factoryConfig.serializerModifiers()) { ser = mod.modifyCollectionSerializer(config, type, beanDesc, ser); } } return ser; } /* /********************************************************** /* Factory methods, for Collections /********************************************************** */ protected boolean isIndexedList(Class<?> cls) { return RandomAccess.class.isAssignableFrom(cls); } public ContainerSerializer<?> buildIndexedListSerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts, JsonSerializer<Object> valueSerializer) { return new IndexedListSerializer(elemType, staticTyping, vts, null, valueSerializer); } public ContainerSerializer<?> buildCollectionSerializer(JavaType elemType, boolean staticTyping,

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> TypeSerializer vts, JsonSerializer<Object> valueSerializer) { return new CollectionSerializer(elemType, staticTyping, vts, null, valueSerializer); } public JsonSerializer<?> buildEnumSetSerializer(JavaType enumType) { return new EnumSetSerializer(enumType, null); } /* /********************************************************** /* Factory methods, for Maps /********************************************************** */ /** * Helper method that handles configuration details when constructing serializers for * {@link java.util.Map} types. */ protected JsonSerializer<?> buildMapSerializer(SerializationConfig config, MapType type, BeanDescription beanDesc, boolean staticTyping, JsonSerializer<Object> keySerializer, TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer) throws JsonMappingException { JsonSerializer<?> ser = null; for (Serializers serializers : customSerializers()) { ser = serializers.findMapSerializer(config, type, beanDesc, keySerializer, elementTypeSerializer, elementValueSerializer); if (ser != null) { break; } } if (ser == null) { // 08-Nov-2014, tatu: As per [databind#601], better just use default Map serializer /* if (EnumMap.class.isAssignableFrom(type.getRawClass()) && ((keySerializer == null) || ClassUtil.isJacksonStdImpl(keySerializer))) { JavaType keyType = type.getKeyType(); // Need to find key enum values... EnumValues enums = null; if (keyType.isEnumType()) { // non-enum if we got it as type erased class (from instance) @SuppressWarnings("unchecked") Class<Enum<?>> enumClass = (Class<Enum<?>>) keyType.getRawClass(); enums = EnumValues.construct(config, enumClass); } ser = new EnumMapSerializer(type.getContentType(), staticTyping, enums, elementTypeSerializer, elementValueSerializer); } else { */ Object filterId = findFilterId(config, beanDesc); MapSerializer mapSer = MapSerializer.construct(config.getAnnotationIntrospector().findPropertiesToIgnore(beanDesc.getClassInfo()), type, staticTyping, elementTypeSerializer, keySerializer, elementValueSerializer, filterId); Object suppressableValue = findSuppressableContentValue

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>(config, type.getContentType(), beanDesc); if (suppressableValue != null) { mapSer = mapSer.withContentInclusion(suppressableValue); } ser = mapSer; } // [Issue#120]: Allow post-processing if (_factoryConfig.hasSerializerModifiers()) { for (BeanSerializerModifier mod : _factoryConfig.serializerModifiers()) { ser = mod.modifyMapSerializer(config, type, beanDesc, ser); } } return ser; } /** * @since 2.5 */ protected Object findSuppressableContentValue(SerializationConfig config, JavaType contentType, BeanDescription beanDesc) throws JsonMappingException { JsonInclude.Include incl = beanDesc.findSerializationInclusionForContent(null); if (incl != null) { switch (incl) { case NON_DEFAULT: // 19-Oct-2014, tatu: Not sure what this'd mean; so take it to mean "NON_EMPTY"... incl = JsonInclude.Include.NON_EMPTY; break; default: // all other modes actually good as is, unless we'll find better ways break; } return incl; } return null; } /* /********************************************************** /* Factory methods, for Arrays /********************************************************** */ /** * Helper method that handles configuration details when constructing serializers for * <code>Object[]</code> (and subtypes, except for String). */ protected JsonSerializer<?> buildArraySerializer(SerializationConfig config, ArrayType type, BeanDescription beanDesc, boolean staticTyping, TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer) throws JsonMappingException { JsonSerializer<?> ser = null; // Module-provided custom collection serializers? for (Serializers serializers : customSerializers()) { ser = serializers.findArraySerializer(config, type, beanDesc, elementTypeSerializer, elementValueSerializer); if (ser != null) { break; } } if (ser == null) { Class<?> raw = type.getRawClass(); // Important: do NOT use standard serializers if non-standard element value serializer specified if (elementValueSerializer == null || ClassUtil.isJacksonStdImpl(element

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>ValueSerializer)) { if (String[].class == raw) { ser = StringArraySerializer.instance; } else { // other standard types? ser = StdArraySerializers.findStandardImpl(raw); } } if (ser == null) { ser = new ObjectArraySerializer(type.getContentType(), staticTyping, elementTypeSerializer, elementValueSerializer); } } // [Issue#120]: Allow post-processing if (_factoryConfig.hasSerializerModifiers()) { for (BeanSerializerModifier mod : _factoryConfig.serializerModifiers()) { ser = mod.modifyArraySerializer(config, type, beanDesc, ser); } } return ser; } /* /********************************************************** /* Factory methods, for non-container types /********************************************************** */ /** * @since 2.5 */ protected JsonSerializer<?> buildIteratorSerializer(SerializationConfig config, JavaType type, BeanDescription beanDesc, boolean staticTyping, JavaType valueType) throws JsonMappingException { return new IteratorSerializer(valueType, staticTyping, createTypeSerializer(config, valueType), null); } @Deprecated // since 2.5 protected JsonSerializer<?> buildIteratorSerializer(SerializationConfig config, JavaType type, BeanDescription beanDesc, boolean staticTyping) throws JsonMappingException { JavaType[] params = config.getTypeFactory().findTypeParameters(type, Iterator.class); JavaType vt = (params == null || params.length != 1) ? TypeFactory.unknownType() : params[0]; return buildIteratorSerializer(config, type, beanDesc, staticTyping, vt); } /** * @since 2.5 */ protected JsonSerializer<?> buildIterableSerializer(SerializationConfig config, JavaType type, BeanDescription beanDesc, boolean staticTyping, JavaType valueType) throws JsonMappingException { return new IterableSerializer(valueType, staticTyping, createTypeSerializer(config, valueType), null); } @Deprecated // since 2.5 protected JsonSerializer<?> buildIterableSerializer(SerializationConfig config, JavaType type, BeanDescription beanDesc, boolean staticTyping) throws JsonMappingException { JavaType[] params = config.getTypeFactory().findTypeParameters(type, Iterable.class); JavaType vt =

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> methodName, Class<?> noneClass) { if (src == null) { return null; } if (!(src instanceof Class)) { throw new IllegalStateException("AnnotationIntrospector."+methodName+"() returned value of type "+src.getClass().getName()+": expected type JsonSerializer or Class<JsonSerializer> instead"); } Class<?> cls = (Class<?>) src; if (cls == noneClass || ClassUtil.isBogusClass(cls)) { return null; } return cls; } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std; import com.fasterxml.jackson.core.JsonGenerationException; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.SerializerProvider; import com.fasterxml.jackson.databind.jsontype.TypeSerializer; import java.io.IOException; import java.net.Inet6Address; import java.net.InetAddress; import java.net.InetSocketAddress; /** * Simple serializer for {@link InetSocketAddress}. */ @SuppressWarnings("serial") public class InetSocketAddressSerializer extends StdScalarSerializer<InetSocketAddress> { public InetSocketAddressSerializer() { super(InetSocketAddress.class); } @Override public void serialize(InetSocketAddress value, JsonGenerator jgen, SerializerProvider provider) throws IOException { InetAddress addr = value.getAddress(); String str = addr == null ? value.getHostName() : addr.toString().trim(); int ix = str.indexOf('/'); if (ix >= 0) { if (ix == 0) { // missing host name; use address str = addr instanceof Inet6Address ? "[" + str.substring(1) + "]" // bracket IPv6 addresses with : str.substring(1); } else { // otherwise use name str = str.substring(0, ix); } } jgen.writeString(str + ":" + value.getPort()); } @Override public void serializeWithType(InetSocketAddress value, JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer) throws IOException, JsonGenerationException { // Better ensure we don't use specific sub-classes... typeSer.writeTypePrefixForScalar(value, jgen, InetSocketAddress.class); serialize(value, jgen, provider); typeSer.writeTypeSuffixForScalar(value, jgen); } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> changed to only include non-null properties, or properties * with non-default values. */ protected JsonInclude.Include _serializationInclusion = null; /** * Object used for resolving filter ids to filter instances. * Non-null if explicitly defined; null by default. */ protected final FilterProvider _filterProvider; /** * States of {@link com.fasterxml.jackson.core.JsonGenerator.Feature}s to enable/disable. */ protected final int _generatorFeatures; /** * Bitflag of {@link com.fasterxml.jackson.core.JsonGenerator.Feature}s to enable/disable */ protected final int _generatorFeaturesToChange; /* /********************************************************** /* Life-cycle, constructors /********************************************************** */ /** * Constructor used by ObjectMapper to create default configuration object instance. */ public SerializationConfig(BaseSettings base, SubtypeResolver str, Map<ClassKey,Class<?>> mixins) { super(base, str, mixins); _serFeatures = collectFeatureDefaults(SerializationFeature.class); _filterProvider = null; _generatorFeatures = 0; _generatorFeaturesToChange = 0; } private SerializationConfig(SerializationConfig src, SubtypeResolver str) { super(src, str); _serFeatures = src._serFeatures; _serializationInclusion = src._serializationInclusion; _filterProvider = src._filterProvider; _generatorFeatures = src._generatorFeatures; _generatorFeaturesToChange = src._generatorFeaturesToChange; } private SerializationConfig(SerializationConfig src, int mapperFeatures, int serFeatures, int generatorFeatures, int generatorFeatureMask) { super(src, mapperFeatures); _serFeatures = serFeatures; _serializationInclusion = src._serializationInclusion; _filterProvider = src._filterProvider; _generatorFeatures = generatorFeatures; _generatorFeaturesToChange = generatorFeatureMask; } private SerializationConfig(SerializationConfig src, BaseSettings base) { super(src, base); _serFeatures = src._serFeatures; _serializationInclusion = src._serializationInclusion; _filterProvider = src._filterProvider; _generatorFeatures = src._generatorFeatures; _generatorFeaturesToChange = src._generatorFeaturesToChange;

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.util; import com.fasterxml.jackson.databind.JavaType; import com.fasterxml.jackson.databind.type.TypeFactory; /** * Standard implementation of {@link Converter} that supports explicit * type access, instead of relying type detection of generic type * parameters. * * @since 2.2 */ public abstract class StdConverter<IN,OUT> implements Converter<IN,OUT> { /* /********************************************************** /* Partial Converter API implementation /********************************************************** */ @Override public abstract OUT convert(IN value); @Override public JavaType getInputType(TypeFactory typeFactory) { JavaType[] types = typeFactory.findTypeParameters(getClass(), Converter.class); if (types == null || types.length < 2) { throw new IllegalStateException("Can not find OUT type parameter for Converter of type "+getClass().getName()); } return types[0]; } @Override public JavaType getOutputType(TypeFactory typeFactory) { JavaType[] types = typeFactory.findTypeParameters(getClass(), Converter.class); if (types == null || types.length < 2) { throw new IllegalStateException("Can not find OUT type parameter for Converter of type "+getClass().getName()); } return types[1]; } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>, StringBuffer toAppendTo, FieldPosition fieldPosition) { if (_formatISO8601 == null) { _formatISO8601 = _cloneFormat(DATE_FORMAT_ISO8601, DATE_FORMAT_STR_ISO8601, _timezone, _locale); } return _formatISO8601.format(date, toAppendTo, fieldPosition); } /* /********************************************************** /* Std overrides /********************************************************** */ @Override public String toString() { String str = "DateFormat "+getClass().getName(); TimeZone tz = _timezone; if (tz != null) { str += " (timezone: "+tz+")"; } str += "(locale: "+_locale+")"; return str; } /* /********************************************************** /* Helper methods /********************************************************** */ /** * Overridable helper method used to figure out which of supported * formats is the likeliest match. */ protected boolean looksLikeISO8601(String dateStr) { if (dateStr.length() >= 5 && Character.isDigit(dateStr.charAt(0)) && Character.isDigit(dateStr.charAt(3)) && dateStr.charAt(4) == '-' ) { return true; } return false; } protected Date parseAsISO8601(String dateStr, ParsePosition pos) { /* 21-May-2009, tatu: DateFormat has very strict handling of * timezone modifiers for ISO-8601. So we need to do some scrubbing. */ /* First: do we have "zulu" format ('Z' == "GMT")? If yes, that's * quite simple because we already set date format timezone to be * GMT, and hence can just strip out 'Z' altogether */ int len = dateStr.length(); char c = dateStr.charAt(len-1); DateFormat df; // [JACKSON-200]: need to support "plain" date... if (len <= 10 && Character.isDigit(c)) { df = _formatPlain; if (df == null) { df = _formatPlain

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>str = new SerializedString(_simpleName); } else { sstr = config.compileString(_simpleName); } _encodedSimple = sstr; } return sstr; } public String getNamespace() { return _namespace; } public boolean hasSimpleName() { return _simpleName.length() > 0; } /** * @since 2.3 */ public boolean hasSimpleName(String str) { if (str == null) { return _simpleName == null; } return str.equals(_simpleName); } public boolean hasNamespace() { return _namespace != null; } /** * Method that is basically equivalent of: *<pre> * !hasSimpleName() && !hasNamespace(); *</pre> * * @since 2.4 */ public boolean isEmpty() { return (_namespace == null) && (_simpleName.isEmpty()); } /* /********************************************************** /* Std method overrides /********************************************************** */ @Override public boolean equals(Object o) { if (o == this) return true; if (o == null) return false; /* 13-Nov-2012, tatu: by default, require strict type equality. * Re-evaluate if this becomes an issue. */ if (o.getClass() != getClass()) return false; // 13-Nov-2012, tatu: Should we have specific rules on matching USE_DEFAULT? // (like, it only ever matching exact instance) // If we did, would need to check symmetrically; that is, if either 'this' // or 'o' was USE_DEFAULT, both would have to be. PropertyName other = (PropertyName) o; if (_simpleName == null) { if (other._simpleName != null) return false; } else if (!_simpleName.equals(other._simpleName)) { return false; } if (_namespace == null) { return (null == other._namespace); } return _namespace.equals(other._namespace); } @Override public int hashCode() { if (_namespace == null) { return _simpleName.hashCode(); }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>type annotations, * find out full type, and figure out which actual factory method * to call. */ @SuppressWarnings("unchecked") protected JsonDeserializer<Object> _createDeserializer(DeserializationContext ctxt, DeserializerFactory factory, JavaType type) throws JsonMappingException { final DeserializationConfig config = ctxt.getConfig(); // First things first: do we need to use abstract type mapping? if (type.isAbstract() || type.isMapLikeType() || type.isCollectionLikeType()) { type = factory.mapAbstractType(config, type); } BeanDescription beanDesc; try { beanDesc = config.introspect(type); } catch (NoClassDefFoundError error) { return new NoClassDefFoundDeserializer<Object>(error); } // Then: does type define explicit deserializer to use, with annotation(s)? JsonDeserializer<Object> deser = findDeserializerFromAnnotation(ctxt, beanDesc.getClassInfo()); if (deser != null) { return deser; } // If not, may have further type-modification annotations to check: JavaType newType = modifyTypeByAnnotation(ctxt, beanDesc.getClassInfo(), type); if (newType != type) { type = newType; beanDesc = config.introspect(newType); } // We may also have a Builder type to consider... Class<?> builder = beanDesc.findPOJOBuilder(); if (builder != null) { return (JsonDeserializer<Object>) factory.createBuilderBasedDeserializer( ctxt, type, beanDesc, builder); } // Or perhaps a Converter? Converter<Object,Object> conv = beanDesc.findDeserializationConverter(); if (conv == null) { // nope, just construct in normal way return (JsonDeserializer<Object>) _createDeserializer2(ctxt, factory, type, beanDesc); } // otherwise need to do bit of introspection JavaType delegateType = conv.getInputType(ctxt.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); } return new StdDelegatingDeserializer<Object>(conv

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>, delegateType, _createDeserializer2(ctxt, factory, delegateType, beanDesc)); } protected JsonDeserializer<?> _createDeserializer2(DeserializationContext ctxt, DeserializerFactory factory, JavaType type, BeanDescription beanDesc) throws JsonMappingException { final DeserializationConfig config = ctxt.getConfig(); // If not, let's see which factory method to use: if (type.isEnumType()) { return factory.createEnumDeserializer(ctxt, type, beanDesc); } if (type.isContainerType()) { if (type.isArrayType()) { return factory.createArrayDeserializer(ctxt, (ArrayType) type, beanDesc); } if (type.isMapLikeType()) { MapLikeType mlt = (MapLikeType) type; if (mlt.isTrueMapType()) { return factory.createMapDeserializer(ctxt,(MapType) mlt, beanDesc); } return factory.createMapLikeDeserializer(ctxt, mlt, beanDesc); } if (type.isCollectionLikeType()) { /* 03-Aug-2012, tatu: As per [Issue#40], one exception is if shape * is to be Shape.OBJECT. Ideally we'd determine it bit later on * (to allow custom handler checks), but that won't work for other * reasons. So do it here. */ JsonFormat.Value format = beanDesc.findExpectedFormat(null); if (format == null || format.getShape() != JsonFormat.Shape.OBJECT) { CollectionLikeType clt = (CollectionLikeType) type; if (clt.isTrueCollectionType()) { return factory.createCollectionDeserializer(ctxt, (CollectionType) clt, beanDesc); } return factory.createCollectionLikeDeserializer(ctxt, clt, beanDesc); } } } if (JsonNode.class.isAssignableFrom(type.getRawClass())) { return factory.createTreeDeserializer(config, type, beanDesc); } return factory.createBeanDeserializer(ctxt, type, beanDesc); } /** * Helper method called to check if a class or method * has annotation that tells which class to use for deserialization. * Returns null if no such annotation found. */

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> } } // and finally content class; only applicable to structured types Class<?> cc = intr.findDeserializationContentType(a, type.getContentType()); if (cc != null) { try { type = type.narrowContentsBy(cc); } catch (IllegalArgumentException iae) { throw new JsonMappingException("Failed to narrow content type "+type+" with content-type annotation ("+cc.getName()+"): "+iae.getMessage(), null, iae); } } // ... as well as deserializer for contents: JavaType contentType = type.getContentType(); if (contentType.getValueHandler() == null) { // as with above, avoid resetting (which would trigger exception) Object cdDef = intr.findContentDeserializer(a); if (cdDef != null) { JsonDeserializer<?> cd = null; if (cdDef instanceof JsonDeserializer<?>) { cdDef = (JsonDeserializer<?>) cdDef; } else { Class<?> cdClass = _verifyAsClass(cdDef, "findContentDeserializer", JsonDeserializer.None.class); if (cdClass != null) { cd = ctxt.deserializerInstance(a, cdClass); } } if (cd != null) { type = type.withContentValueHandler(cd); } } } } return type; } /* /********************************************************** /* Helper methods, other /********************************************************** */ /** * Helper method used to prevent both caching and cache lookups for structured * types that have custom value handlers * * @since 2.4.6 */ private boolean _hasCustomValueHandler(JavaType t) { if (t.isContainerType()) { JavaType ct = t.getContentType(); return (ct != null) && (ct.getValueHandler() != null); } return false; } private Class<?> _verifyAsClass(Object src, String methodName, Class<?> noneClass) { if (src == null) { return null; } if (!(src instanceof Class)) { throw new IllegalStateException("AnnotationIntrospector."+methodName+"() returned value of type "+src.getClass().getName()+": expected type JsonSerializer or Class<JsonSerializer> instead"); } Class<?> cls = (Class<?>) src; if

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>(); } @Override public Member getMember() { return _field; } @Override public void setValue(Object pojo, Object value) throws IllegalArgumentException { try { _field.set(pojo, value); } catch (IllegalAccessException e) { throw new IllegalArgumentException("Failed to setValue() for field " +getFullName()+": "+e.getMessage(), e); } } @Override public Object getValue(Object pojo) throws IllegalArgumentException { try { return _field.get(pojo); } catch (IllegalAccessException e) { throw new IllegalArgumentException("Failed to getValue() for field " +getFullName()+": "+e.getMessage(), e); } } /* /********************************************************** /* Extended API, generic /********************************************************** */ public String getFullName() { return getDeclaringClass().getName() + "#" + getName(); } public int getAnnotationCount() { return _annotations.size(); } @Override public int hashCode() { return _field.getName().hashCode(); } @Override public boolean equals(Object o) { if (o == this) return true; if (o == null || o.getClass() != getClass()) return false; return ((AnnotatedField) o)._field == _field; } @Override public String toString() { return "[field "+getFullName()+"]"; } /* /********************************************************** /* JDK serialization handling /********************************************************** */ Object writeReplace() { return new AnnotatedField(new Serialization(_field)); } Object readResolve() { Class<?> clazz = _serialization.clazz; try { Field f = clazz.getDeclaredField(_serialization.name); // 06-Oct-2012, tatu: Has "lost" its security override, may need to force back if (!f.isAccessible()) { ClassUtil.checkAndFixAccess(f); } return new AnnotatedField(null, f, null); } catch (Exception e) { throw new IllegalArgumentException("Could not find method '"+_serialization.name +"' from Class '"+clazz.getName()); } } /** * Helper class that is used as the workaround to persist * Field references. It basically just stores declaring class * and field name. */

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> of contained values */ protected final JavaType _valueType; /** * Key serializer to use, if it can be statically determined */ protected JsonSerializer<Object> _keySerializer; /** * Value serializer to use, if it can be statically determined */ protected JsonSerializer<Object> _valueSerializer; /** * Type identifier serializer used for values, if any. */ protected final TypeSerializer _valueTypeSerializer; /** * If value type can not be statically determined, mapping from * runtime value types to serializers are stored in this object. */ protected PropertySerializerMap _dynamicValueSerializers; /** * Id of the property filter to use, if any; null if none. * * @since 2.3 */ protected final Object _filterId; /** * Flag set if output is forced to be sorted by keys (usually due * to annotation). * * @since 2.4 */ protected final boolean _sortKeys; /** * Value that indicates suppression mechanism to use; either one of * values of {@link com.fasterxml.jackson.annotation.JsonInclude.Include}, or actual object to compare * against ("default value") * * @since 2.5 */ protected final Object _suppressableValue; /* /********************************************************** /* Life-cycle /********************************************************** */ /** * @since 2.5 */ @SuppressWarnings("unchecked") protected MapSerializer(HashSet<String> ignoredEntries, JavaType keyType, JavaType valueType, boolean valueTypeIsStatic, TypeSerializer vts, JsonSerializer<?> keySerializer, JsonSerializer<?> valueSerializer) { super(Map.class, false); _ignoredEntries = ignoredEntries; _keyType = keyType; _valueType = valueType; _valueTypeIsStatic = valueTypeIsStatic; _valueTypeSerializer = vts; _keySerializer = (JsonSerializer<Object>) keySerializer; _valueSerializer = (JsonSerializer<Object>) valueSerializer; _dynamicValueSerializers = PropertySerializerMap.emptyForProperties(); _property = null; _filterId = null; _sortKeys = false; _suppressableValue = null; } /** * @since 2.5 */ protected void _ensure

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>Override() { if (getClass() != MapSerializer.class) { throw new IllegalStateException("Missing override in class "+getClass().getName()); } } @SuppressWarnings("unchecked") protected MapSerializer(MapSerializer src, BeanProperty property, JsonSerializer<?> keySerializer, JsonSerializer<?> valueSerializer, HashSet<String> ignored) { super(Map.class, false); _ignoredEntries = ignored; _keyType = src._keyType; _valueType = src._valueType; _valueTypeIsStatic = src._valueTypeIsStatic; _valueTypeSerializer = src._valueTypeSerializer; _keySerializer = (JsonSerializer<Object>) keySerializer; _valueSerializer = (JsonSerializer<Object>) valueSerializer; _dynamicValueSerializers = src._dynamicValueSerializers; _property = property; _filterId = src._filterId; _sortKeys = src._sortKeys; _suppressableValue = src._suppressableValue; } @Deprecated // since 2.5 protected MapSerializer(MapSerializer src, TypeSerializer vts) { this(src, vts, src._suppressableValue); } /** * @since 2.5 */ protected MapSerializer(MapSerializer src, TypeSerializer vts, Object suppressableValue) { super(Map.class, false); _ignoredEntries = src._ignoredEntries; _keyType = src._keyType; _valueType = src._valueType; _valueTypeIsStatic = src._valueTypeIsStatic; _valueTypeSerializer = vts; _keySerializer = src._keySerializer; _valueSerializer = src._valueSerializer; _dynamicValueSerializers = src._dynamicValueSerializers; _property = src._property; _filterId = src._filterId; _sortKeys = src._sortKeys; _suppressableValue = suppressableValue; } protected MapSerializer(MapSerializer src, Object filterId, boolean sortKeys) { super(Map.class, false); _ignoredEntries = src._ignoredEntries; _keyType = src._keyType; _valueType = src._valueType; _valueTypeIsStatic = src._valueTypeIsStatic; _valueTypeSerializer = src._valueTypeSerializer; _keySerializer = src._keySerializer; _valueSerializer = src

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> keyType = mapType.getKeyType(); valueType = mapType.getContentType(); } // If value type is final, it's same as forcing static value typing: if (!staticValueType) { staticValueType = (valueType != null && valueType.isFinal()); } else { // also: Object.class can not be handled as static, ever if (valueType.getRawClass() == Object.class) { staticValueType = false; } } MapSerializer ser = new MapSerializer(ignoredEntries, keyType, valueType, staticValueType, vts, keySerializer, valueSerializer); if (filterId != null) { ser = ser.withFilterId(filterId); } return ser; } /* /********************************************************** /* Post-processing (contextualization) /********************************************************** */ @Override public JsonSerializer<?> createContextual(SerializerProvider provider, BeanProperty property) throws JsonMappingException { /* 29-Sep-2012, tatu: Actually, we need to do much more contextual * checking here since we finally know for sure the property, * and it may have overrides */ JsonSerializer<?> ser = null; JsonSerializer<?> keySer = null; final AnnotationIntrospector intr = provider.getAnnotationIntrospector(); final AnnotatedMember propertyAcc = (property == null) ? null : property.getMember(); Object suppressableValue = _suppressableValue; // First: if we have a property, may have property-annotation overrides if (propertyAcc != null && intr != null) { Object serDef = intr.findKeySerializer(propertyAcc); if (serDef != null) { keySer = provider.serializerInstance(propertyAcc, serDef); } serDef = intr.findContentSerializer(propertyAcc); if (serDef != null) { ser = provider.serializerInstance(propertyAcc, serDef); } JsonInclude.Include incl = intr.findSerializationInclusionForContent(propertyAcc, null); if (incl != null) { suppressableValue = incl; } } if (ser == null) { ser = _valueSerializer; } // [Issue#124]: May have a content converter ser = findConvertingContent

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>Serializer(provider, property, ser); if (ser == null) { // 30-Sep-2012, tatu: One more thing -- if explicit content type is annotated, // we can consider it a static case as well. // 20-Aug-2013, tatu: Need to avoid trying to access serializer for java.lang.Object tho if ((_valueTypeIsStatic && _valueType.getRawClass() != Object.class) || hasContentTypeAnnotation(provider, property)) { ser = provider.findValueSerializer(_valueType, property); } } else { ser = provider.handleSecondaryContextualization(ser, property); } if (keySer == null) { keySer = _keySerializer; } if (keySer == null) { keySer = provider.findKeySerializer(_keyType, property); } else { keySer = provider.handleSecondaryContextualization(keySer, property); } HashSet<String> ignored = _ignoredEntries; boolean sortKeys = false; if (intr != null && propertyAcc != null) { String[] moreToIgnore = intr.findPropertiesToIgnore(propertyAcc); if (moreToIgnore != null) { ignored = (ignored == null) ? new HashSet<String>() : new HashSet<String>(ignored); for (String str : moreToIgnore) { ignored.add(str); } } Boolean b = intr.findSerializationSortAlphabetically(propertyAcc); sortKeys = (b != null) && b.booleanValue(); } MapSerializer mser = withResolved(property, keySer, ser, ignored, sortKeys); if (suppressableValue != _suppressableValue) { mser = mser.withContentInclusion(suppressableValue); } // [Issue#307]: allow filtering if (property != null) { AnnotatedMember m = property.getMember(); if (m != null) { Object filterId = intr.findFilterId(m); if (filterId != null) { mser = mser.withFilterId(filterId); } } } return mser; } /* /********************************************************** /* Accessors /********************************************************** */ @

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>valueSerializer); } else { serializeFields(value, gen, provider); } } gen.writeEndObject(); } @Override public void serializeWithType(Map<?,?> value, JsonGenerator gen, SerializerProvider provider, TypeSerializer typeSer) throws IOException { typeSer.writeTypePrefixForObject(value, gen); // [databind#631]: Assign current value, to be accessible by custom serializers gen.setCurrentValue(value); if (!value.isEmpty()) { Object suppressableValue = _suppressableValue; if (suppressableValue == null) { if (!provider.isEnabled(SerializationFeature.WRITE_NULL_MAP_VALUES)) { suppressableValue = JsonInclude.Include.NON_NULL; } } else if (suppressableValue == JsonInclude.Include.ALWAYS) { suppressableValue = null; } if (_sortKeys || provider.isEnabled(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS)) { value = _orderEntries(value); } if (_filterId != null) { serializeFilteredFields(value, gen, provider, findPropertyFilter(provider, _filterId, value), suppressableValue); } else if (suppressableValue != null) { serializeOptionalFields(value, gen, provider, suppressableValue); } else if (_valueSerializer != null) { serializeFieldsUsing(value, gen, provider, _valueSerializer); } else { serializeFields(value, gen, provider); } } typeSer.writeTypeSuffixForObject(value, gen); } /* /********************************************************** /* JsonSerializer implementation /********************************************************** */ /** * Method called to serialize fields, when the value type is not statically known; * but we know that no value suppression is needed (which simplifies processing a bit) */ public void serializeFields(Map<?,?> value, JsonGenerator gen, SerializerProvider provider) throws IOException { // If value type needs polymorphic type handling, some more work needed: if (_valueTypeSerializer != null) { serializeTypedFields(value, gen, provider, null); return; } final JsonSerializer<Object> keySerializer = _keySerializer; final HashSet<String> ignored = _ignoredEntries; PropertySerializerMap serializers

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> = _dynamicValueSerializers; for (Map.Entry<?,?> entry : value.entrySet()) { Object valueElem = entry.getValue(); // First, serialize key Object keyElem = entry.getKey(); if (keyElem == null) { provider.findNullKeySerializer(_keyType, _property).serialize(null, gen, provider); } else { // One twist: is entry ignorable? If so, skip if (ignored != null && ignored.contains(keyElem)) continue; keySerializer.serialize(keyElem, gen, provider); } // And then value if (valueElem == null) { provider.defaultSerializeNull(gen); } else { Class<?> cc = valueElem.getClass(); JsonSerializer<Object> serializer = serializers.serializerFor(cc); if (serializer == null) { if (_valueType.hasGenericTypes()) { serializer = _findAndAddDynamic(serializers, provider.constructSpecializedType(_valueType, cc), provider); } else { serializer = _findAndAddDynamic(serializers, cc, provider); } serializers = _dynamicValueSerializers; } try { serializer.serialize(valueElem, gen, provider); } catch (Exception e) { // Add reference information String keyDesc = ""+keyElem; wrapAndThrow(provider, e, value, keyDesc); } } } } public void serializeOptionalFields(Map<?,?> value, JsonGenerator gen, SerializerProvider provider, Object suppressableValue) throws IOException { // If value type needs polymorphic type handling, some more work needed: if (_valueTypeSerializer != null) { serializeTypedFields(value, gen, provider, suppressableValue); return; } final HashSet<String> ignored = _ignoredEntries; PropertySerializerMap serializers = _dynamicValueSerializers; for (Map.Entry<?,?> entry : value.entrySet()) { // First find key serializer final Object keyElem = entry.getKey(); JsonSerializer<Object> keySerializer; if (keyElem == null) { keySerializer = provider.findNullKeySerializer(_keyType, _property); } else { if (ignored != null && ignored.contains(keyElem)) continue; keySerializer = _keySerializer; }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> // Then value serializer final Object valueElem = entry.getValue(); JsonSerializer<Object> valueSer; if (valueElem == null) { if (suppressableValue != null) { // all suppressions include null-suppression continue; } valueSer = provider.getDefaultNullValueSerializer(); } else { valueSer = _valueSerializer; if (valueSer == null) { Class<?> cc = valueElem.getClass(); valueSer = serializers.serializerFor(cc); if (valueSer == null) { if (_valueType.hasGenericTypes()) { valueSer = _findAndAddDynamic(serializers, provider.constructSpecializedType(_valueType, cc), provider); } else { valueSer = _findAndAddDynamic(serializers, cc, provider); } serializers = _dynamicValueSerializers; } } // also may need to skip non-empty values: if ((suppressableValue == JsonInclude.Include.NON_EMPTY) && valueSer.isEmpty(provider, valueElem)) { continue; } } // and then serialize, if all went well try { keySerializer.serialize(keyElem, gen, provider); valueSer.serialize(valueElem, gen, provider); } catch (Exception e) { String keyDesc = ""+keyElem; wrapAndThrow(provider, e, value, keyDesc); } } } /** * Method called to serialize fields, when the value type is statically known, * so that value serializer is passed and does not need to be fetched from * provider. */ protected void serializeFieldsUsing(Map<?,?> value, JsonGenerator gen, SerializerProvider provider, JsonSerializer<Object> ser) throws IOException { final JsonSerializer<Object> keySerializer = _keySerializer; final HashSet<String> ignored = _ignoredEntries; final TypeSerializer typeSer = _valueTypeSerializer; for (Map.Entry<?,?> entry : value.entrySet()) { Object keyElem = entry.getKey(); if (ignored != null && ignored.contains(keyElem)) continue; if (keyElem == null) { provider.findNullKeySerializer(_keyType, _property).serialize(null, gen, provider); } else { keySerializer.serialize(keyElem, gen, provider);

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> } final Object valueElem = entry.getValue(); if (valueElem == null) { provider.defaultSerializeNull(gen); } else { try { if (typeSer == null) { ser.serialize(valueElem, gen, provider); } else { ser.serializeWithType(valueElem, gen, provider, typeSer); } } catch (Exception e) { String keyDesc = ""+keyElem; wrapAndThrow(provider, e, value, keyDesc); } } } } /** * Helper method used when we have a JSON Filter to use for potentially * filtering out Map entries. * * @since 2.5 */ public void serializeFilteredFields(Map<?,?> value, JsonGenerator gen, SerializerProvider provider, PropertyFilter filter, Object suppressableValue) // since 2.5 throws IOException { final HashSet<String> ignored = _ignoredEntries; PropertySerializerMap serializers = _dynamicValueSerializers; final MapProperty prop = new MapProperty(_valueTypeSerializer, _property); for (Map.Entry<?,?> entry : value.entrySet()) { // First, serialize key; unless ignorable by key final Object keyElem = entry.getKey(); if (ignored != null && ignored.contains(keyElem)) continue; JsonSerializer<Object> keySerializer; if (keyElem == null) { keySerializer = provider.findNullKeySerializer(_keyType, _property); } else { keySerializer = _keySerializer; } // or by value; nulls often suppressed final Object valueElem = entry.getValue(); JsonSerializer<Object> valueSer; // And then value if (valueElem == null) { if (suppressableValue != null) { // all suppressions include null-suppression continue; } valueSer = provider.getDefaultNullValueSerializer(); } else { valueSer = _valueSerializer; if (valueSer == null) { Class<?> cc = valueElem.getClass(); valueSer = serializers.serializerFor(cc); if (valueSer == null) { if (_valueType.hasGenericTypes()) { valueSer = _findAndAddDynamic(serializers, provider.constructSpecializedType(_valueType, cc), provider); } else { value

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>Ser = _findAndAddDynamic(serializers, cc, provider); } serializers = _dynamicValueSerializers; } } // also may need to skip non-empty values: if ((suppressableValue == JsonInclude.Include.NON_EMPTY) && valueSer.isEmpty(provider, valueElem)) { continue; } } // and with that, ask filter to handle it prop.reset(keyElem, keySerializer, valueSer); try { filter.serializeAsField(valueElem, gen, provider, prop); } catch (Exception e) { String keyDesc = ""+keyElem; wrapAndThrow(provider, e, value, keyDesc); } } } @Deprecated // since 2.5 public void serializeFilteredFields(Map<?,?> value, JsonGenerator gen, SerializerProvider provider, PropertyFilter filter) throws IOException { serializeFilteredFields(value, gen, provider, filter, provider.isEnabled(SerializationFeature.WRITE_NULL_MAP_VALUES) ? null : JsonInclude.Include.NON_NULL); } /** * @since 2.5 */ protected void serializeTypedFields(Map<?,?> value, JsonGenerator gen, SerializerProvider provider, Object suppressableValue) // since 2.5 throws IOException { final HashSet<String> ignored = _ignoredEntries; PropertySerializerMap serializers = _dynamicValueSerializers; for (Map.Entry<?,?> entry : value.entrySet()) { Object keyElem = entry.getKey(); JsonSerializer<Object> keySerializer; if (keyElem == null) { keySerializer = provider.findNullKeySerializer(_keyType, _property); } else { // One twist: is entry ignorable? If so, skip if (ignored != null && ignored.contains(keyElem)) continue; keySerializer = _keySerializer; } final Object valueElem = entry.getValue(); // And then value JsonSerializer<Object> valueSer; if (valueElem == null) { if (suppressableValue != null) { // all suppression include null suppression continue; } valueSer = provider.getDefaultNullValueSerializer(); } else { valueSer = _valueSerializer; Class<?> cc = valueElem.getClass(); valueSer = serializers.serializer

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>For(cc); if (valueSer == null) { if (_valueType.hasGenericTypes()) { valueSer = _findAndAddDynamic(serializers, provider.constructSpecializedType(_valueType, cc), provider); } else { valueSer = _findAndAddDynamic(serializers, cc, provider); } serializers = _dynamicValueSerializers; } // also may need to skip non-empty values: if ((suppressableValue == JsonInclude.Include.NON_EMPTY) && valueSer.isEmpty(provider, valueElem)) { continue; } } keySerializer.serialize(keyElem, gen, provider); try { valueSer.serializeWithType(valueElem, gen, provider, _valueTypeSerializer); } catch (Exception e) { String keyDesc = ""+keyElem; wrapAndThrow(provider, e, value, keyDesc); } } } @Deprecated // since 2.5 protected void serializeTypedFields(Map<?,?> value, JsonGenerator gen, SerializerProvider provider) throws IOException { serializeTypedFields(value, gen, provider, provider.isEnabled(SerializationFeature.WRITE_NULL_MAP_VALUES) ? null : JsonInclude.Include.NON_NULL); } /* /********************************************************** /* Schema related functionality /********************************************************** */ @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) { ObjectNode o = createSchemaNode("object", true); //(ryan) even though it's possible to statically determine the "value" type of the map, // there's no way to statically determine the keys, so the "Entries" can't be determined. return o; } @Override public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException { JsonMapFormatVisitor v2 = (visitor == null) ? null : visitor.expectMapFormat(typeHint); if (v2 != null) { v2.keyFormat(_keySerializer, _keyType); JsonSerializer<?> valueSer = _valueSerializer; if (valueSer == null) { valueSer = _findAndAddDynamic(_dynamicValueSerializers, _valueType, visitor.getProvider()); } v2.valueFormat(valueSer

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std; import java.io.IOException; import java.lang.reflect.Type; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.JavaType; import com.fasterxml.jackson.databind.JsonMappingException; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.SerializerProvider; import com.fasterxml.jackson.databind.annotation.JacksonStdImpl; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonStringFormatVisitor; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonValueFormat; @JacksonStdImpl @SuppressWarnings("serial") public class SqlTimeSerializer extends StdScalarSerializer<java.sql.Time> { public SqlTimeSerializer() { super(java.sql.Time.class); } @Override public void serialize(java.sql.Time value, JsonGenerator jgen, SerializerProvider provider) throws IOException { jgen.writeString(value.toString()); } @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) { return createSchemaNode("string", true); } @Override public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException { JsonStringFormatVisitor v2 = (visitor == null) ? null : visitor.expectStringFormat(typeHint); if (v2 != null) { v2.format(JsonValueFormat.DATE_TIME); } } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> // Issue#381 if (t == JsonToken.START_ARRAY && ctxt.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS)) { jp.nextToken(); final String parsed = _parseString(jp, ctxt); if (jp.nextToken() != JsonToken.END_ARRAY) { throw ctxt.wrongTokenException(jp, JsonToken.END_ARRAY, "Attempted to unwrap single value array for single 'String' value but there was more than a single value in the array"); } return parsed; } String value = jp.getValueAsString(); if (value != null) { return value; } throw ctxt.mappingException(String.class, jp.getCurrentToken()); } /** * Helper method that may be used to support fallback for Empty String / Empty Array * non-standard representations; usually for things serialized as JSON Objects. * * @since 2.5 */ protected T _deserializeFromEmpty(JsonParser jp, DeserializationContext ctxt) throws IOException { JsonToken t = jp.getCurrentToken(); if (t == JsonToken.START_ARRAY) { if (ctxt.isEnabled(DeserializationFeature.ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT)) { t = jp.nextToken(); if (t == JsonToken.END_ARRAY) { return null; } throw ctxt.mappingException(handledType(), JsonToken.START_ARRAY); } } else if (t == JsonToken.VALUE_STRING) { if (ctxt.isEnabled(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT)) { String str = jp.getText().trim(); if (str.isEmpty()) { return null; } } } throw ctxt.mappingException(handledType()); } /** * Helper method called to determine if we are seeing String value of * "null", and, further, that it should be coerced to null just like * null token. * * @since 2.3 */ protected boolean _hasTextualNull(String value) { return "null".equals(value); } protected final boolean _isNegInf(String text) { return "-Infinity".equals(text) || "-INF".equals(text);

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser.std; import java.io.IOException; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.annotation.JacksonStdImpl; import com.fasterxml.jackson.databind.deser.ContextualDeserializer; import com.fasterxml.jackson.databind.jsontype.TypeDeserializer; import com.fasterxml.jackson.databind.util.ObjectBuffer; /** * Separate implementation for serializing String arrays (instead of * using {@link ObjectArrayDeserializer}. * Used if (and only if) no custom value deserializers are used. */ @JacksonStdImpl public final class StringArrayDeserializer extends StdDeserializer<String[]> implements ContextualDeserializer { private static final long serialVersionUID = 1L; public final static StringArrayDeserializer instance = new StringArrayDeserializer(); /** * Value serializer to use, if not the standard one (which is inlined) */ protected JsonDeserializer<String> _elementDeserializer; public StringArrayDeserializer() { super(String[].class); _elementDeserializer = null; } @SuppressWarnings("unchecked") protected StringArrayDeserializer(JsonDeserializer<?> deser) { super(String[].class); _elementDeserializer = (JsonDeserializer<String>) deser; } @Override public String[] deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException { // Ok: must point to START_ARRAY (or equivalent) if (!jp.isExpectedStartArrayToken()) { return handleNonArray(jp, ctxt); } if (_elementDeserializer != null) { return _deserializeCustom(jp, ctxt); } final ObjectBuffer buffer = ctxt.leaseObjectBuffer(); Object[] chunk = buffer.resetAndStart(); int ix = 0; try { while (true) { String value = jp.nextTextValue(); if (value == null) { JsonToken t = jp.getCurrentToken(); if (t == JsonToken.END_ARRAY) { break; } if (t != JsonToken.VALUE_NULL) { value = _parseString(jp, ctxt); } } if (ix >= chunk.length) { chunk = buffer.append

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>CompletedChunk(chunk); ix = 0; } chunk[ix++] = value; } } catch (Exception e) { throw JsonMappingException.wrapWithPath(e, chunk, buffer.bufferedSize() + ix); } String[] result = buffer.completeAndClearBuffer(chunk, ix, String.class); ctxt.returnObjectBuffer(buffer); return result; } /** * Offlined version used when we do not use the default deserialization method. */ protected final String[] _deserializeCustom(JsonParser jp, DeserializationContext ctxt) throws IOException { final ObjectBuffer buffer = ctxt.leaseObjectBuffer(); Object[] chunk = buffer.resetAndStart(); final JsonDeserializer<String> deser = _elementDeserializer; int ix = 0; try { while (true) { /* 30-Dec-2014, tatu: This may look odd, but let's actually call method * that suggest we are expecting a String; this helps with some formats, * notably XML. Note, however, that while we can get String, we can't * assume that's what we use due to custom deserializer */ String value; if (jp.nextTextValue() == null) { JsonToken t = jp.getCurrentToken(); if (t == JsonToken.END_ARRAY) { break; } // Ok: no need to convert Strings, but must recognize nulls value = (t == JsonToken.VALUE_NULL) ? deser.getNullValue() : deser.deserialize(jp, ctxt); } else { value = deser.deserialize(jp, ctxt); } if (ix >= chunk.length) { chunk = buffer.appendCompletedChunk(chunk); ix = 0; } chunk[ix++] = value; } } catch (Exception e) { // note: pass String.class, not String[].class, as we need element type for error info throw JsonMappingException.wrapWithPath(e, String.class, ix); } String[] result = buffer.completeAndClearBuffer(chunk, ix, String.class); ctxt.returnObjectBuffer(buffer); return result; } @Override public Object deserializeWithType(JsonParser jp, Deserial

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>izationContext ctxt, TypeDeserializer typeDeserializer) throws IOException { return typeDeserializer.deserializeTypedFromArray(jp, ctxt); } private final String[] handleNonArray(JsonParser jp, DeserializationContext ctxt) throws IOException { // [JACKSON-526]: implicit arrays from single values? if (!ctxt.isEnabled(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY)) { // [JACKSON-620] Empty String can become null... if ((jp.getCurrentToken() == JsonToken.VALUE_STRING) && ctxt.isEnabled(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT)) { String str = jp.getText(); if (str.length() == 0) { return null; } } throw ctxt.mappingException(_valueClass); } return new String[] { (jp.getCurrentToken() == JsonToken.VALUE_NULL) ? null : _parseString(jp, ctxt) }; } /** * Contextualization is needed to see whether we can "inline" deserialization * of String values, or if we have to use separate value deserializer. */ @Override public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException { JsonDeserializer<?> deser = _elementDeserializer; // #125: May have a content converter deser = findConvertingContentDeserializer(ctxt, property, deser); JavaType type = ctxt.constructType(String.class); if (deser == null) { deser = ctxt.findContextualValueDeserializer(type, property); } else { // if directly assigned, probably not yet contextual, so: deser = ctxt.handleSecondaryContextualization(deser, property, type); } // Ok ok: if all we got is the default String deserializer, can just forget about it if (deser != null && this.isDefaultDeserializer(deser)) { deser = null; } if (_elementDeserializer != deser) { return new StringArrayDeserializer(deser); } return this; } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.type; import java.lang.reflect.*; import java.util.*; import com.fasterxml.jackson.databind.JavaType; /** * Helper class used for resolving type parameters for given class */ public class TypeBindings { private final static JavaType[] NO_TYPES = new JavaType[0]; /** * Marker to use for (temporarily) unbound references. */ public final static JavaType UNBOUND = new SimpleType(Object.class); /** * Factory to use for constructing resolved related types. */ protected final TypeFactory _typeFactory; /** * Context type used for resolving all types, if specified. May be null, * in which case {@link #_contextClass} is used instead. */ protected final JavaType _contextType; /** * Specific class to use for resolving all types, for methods and fields * class and its superclasses and -interfaces contain. */ protected final Class<?> _contextClass; /** * Lazily-instantiated bindings of resolved type parameters */ protected Map<String,JavaType> _bindings; /** * Also: we may temporarily want to mark certain named types * as resolved (but without exact type); if so, we'll just store * names here. */ protected HashSet<String> _placeholders; /** * Sometimes it is necessary to allow hierarchic resolution of types: specifically * in cases where there are local bindings (for methods, constructors). If so, * we'll just use simple delegation model. */ private final TypeBindings _parentBindings; /* /********************************************************** /* Construction /********************************************************** */ public TypeBindings(TypeFactory typeFactory, Class<?> cc) { this(typeFactory, null, cc, null); } public TypeBindings(TypeFactory typeFactory, JavaType type) { this(typeFactory, null, type.getRawClass(), type); } /** * Constructor used to create "child" instances; mostly to * allow delegation from explicitly defined local overrides * (local type variables for methods, constructors) to * contextual (class-defined) ones. */ public TypeBindings childInstance() { return new TypeBindings(_typeFactory, this, _

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std; import java.io.IOException; import java.util.*; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.annotation.JacksonStdImpl; import com.fasterxml.jackson.databind.jsontype.TypeSerializer; import com.fasterxml.jackson.databind.ser.ContainerSerializer; @JacksonStdImpl @SuppressWarnings("serial") public class IterableSerializer extends AsArraySerializerBase<Iterable<?>> { public IterableSerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts, BeanProperty property) { super(Iterable.class, elemType, staticTyping, vts, property, null); } public IterableSerializer(IterableSerializer src, BeanProperty property, TypeSerializer vts, JsonSerializer<?> valueSerializer) { super(src, property, vts, valueSerializer); } @Override public ContainerSerializer<?> _withValueTypeSerializer(TypeSerializer vts) { return new IterableSerializer(_elementType, _staticTyping, vts, _property); } @Override public IterableSerializer withResolved(BeanProperty property, TypeSerializer vts, JsonSerializer<?> elementSerializer) { return new IterableSerializer(this, property, vts, elementSerializer); } @Override public boolean isEmpty(SerializerProvider prov, Iterable<?> value) { // Not really good way to implement this, but has to do for now: return (value == null) || !value.iterator().hasNext(); } @Override public boolean hasSingleElement(Iterable<?> value) { // we can do it actually (fixed in 2.3.1) if (value != null) { Iterator<?> it = value.iterator(); if (it.hasNext()) { it.next(); if (!it.hasNext()) { return true; } } } return false; } @Override public final void serialize(Iterable<?> value, JsonGenerator jgen, SerializerProvider provider) throws IOException { if (provider.isEnabled(SerializationFeature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED) && hasSingleElement(value)) { serializeContents(value, jgen, provider); return; } jgen

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>.writeStartArray(); serializeContents(value, jgen, provider); jgen.writeEndArray(); } @Override public void serializeContents(Iterable<?> value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { Iterator<?> it = value.iterator(); if (it.hasNext()) { final TypeSerializer typeSer = _valueTypeSerializer; JsonSerializer<Object> prevSerializer = null; Class<?> prevClass = null; do { Object elem = it.next(); if (elem == null) { provider.defaultSerializeNull(jgen); continue; } JsonSerializer<Object> currSerializer = _elementSerializer; if (currSerializer == null) { // Minor optimization to avoid most lookups: Class<?> cc = elem.getClass(); if (cc == prevClass) { currSerializer = prevSerializer; } else { currSerializer = provider.findValueSerializer(cc, _property); prevSerializer = currSerializer; prevClass = cc; } } if (typeSer == null) { currSerializer.serialize(elem, jgen, provider); } else { currSerializer.serializeWithType(elem, jgen, provider, typeSer); } } while (it.hasNext()); } } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.type; import java.util.*; import com.fasterxml.jackson.databind.JavaType; /** * Type that represents Map-like types; things that consist of key/value pairs but that * do not necessarily implement {@link java.util.Map}, but that do not have enough * introspection functionality to allow for some level of generic handling. * This specifically allows framework to check for configuration and annotation * settings used for Map types, and pass these to custom handlers that may be more * familiar with actual type. */ public class MapLikeType extends TypeBase { private static final long serialVersionUID = 416067702302823522L; /** * Type of keys of Map. */ protected final JavaType _keyType; /** * Type of values of Map. */ protected final JavaType _valueType; /* /********************************************************** /* Life-cycle /********************************************************** */ protected MapLikeType(Class<?> mapType, JavaType keyT, JavaType valueT, Object valueHandler, Object typeHandler, boolean asStatic) { super(mapType, keyT.hashCode() ^ valueT.hashCode(), valueHandler, typeHandler, asStatic); _keyType = keyT; _valueType = valueT; } public static MapLikeType construct(Class<?> rawType, JavaType keyT, JavaType valueT) { // nominally component types will be just Object.class return new MapLikeType(rawType, keyT, valueT, null, null, false); } @Override protected JavaType _narrow(Class<?> subclass) { return new MapLikeType(subclass, _keyType, _valueType, _valueHandler, _typeHandler, _asStatic); } @Override public JavaType narrowContentsBy(Class<?> contentClass) { // Can do a quick check first: if (contentClass == _valueType.getRawClass()) { return this; } return new MapLikeType(_class, _keyType, _valueType.narrowBy(contentClass), _valueHandler, _typeHandler, _asStatic); } @Override public JavaType widenContentsBy(Class<?> contentClass)

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> { if (contentClass == _valueType.getRawClass()) { return this; } return new MapLikeType(_class, _keyType, _valueType.widenBy(contentClass), _valueHandler, _typeHandler, _asStatic); } public JavaType narrowKey(Class<?> keySubclass) { // Can do a quick check first: if (keySubclass == _keyType.getRawClass()) { return this; } return new MapLikeType(_class, _keyType.narrowBy(keySubclass), _valueType, _valueHandler, _typeHandler, _asStatic); } public JavaType widenKey(Class<?> keySubclass) { // Can do a quick check first: if (keySubclass == _keyType.getRawClass()) { return this; } return new MapLikeType(_class, _keyType.widenBy(keySubclass), _valueType, _valueHandler, _typeHandler, _asStatic); } @Override public MapLikeType withTypeHandler(Object h) { return new MapLikeType(_class, _keyType, _valueType, _valueHandler, h, _asStatic); } @Override public MapLikeType withContentTypeHandler(Object h) { return new MapLikeType(_class, _keyType, _valueType.withTypeHandler(h), _valueHandler, _typeHandler, _asStatic); } @Override public MapLikeType withValueHandler(Object h) { return new MapLikeType(_class, _keyType, _valueType, h, _typeHandler, _asStatic); } @Override public MapLikeType withContentValueHandler(Object h) { return new MapLikeType(_class, _keyType, _valueType.withValueHandler(h), _valueHandler, _typeHandler, _asStatic); } @Override public MapLikeType withStaticTyping() { if (_asStatic) { return this; } return new MapLikeType(_class, _keyType, _valueType.withStaticTyping(), _valueHandler, _typeHandler, true); } @Override protected String buildCanonicalName() { StringBuilder sb = new StringBuilder(); sb.append(_class.getName()); if (_keyType !=

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> null) { sb.append('<'); sb.append(_keyType.toCanonical()); sb.append(','); sb.append(_valueType.toCanonical()); sb.append('>'); } return sb.toString(); } /* /********************************************************** /* Public API /********************************************************** */ @Override public boolean isContainerType() { return true; } @Override public boolean isMapLikeType() { return true; } @Override public JavaType getKeyType() { return _keyType; } @Override public JavaType getContentType() { return _valueType; } @Override public int containedTypeCount() { return 2; } @Override public JavaType containedType(int index) { if (index == 0) return _keyType; if (index == 1) return _valueType; return null; } /** * Not sure if we should count on this, but type names * for core interfaces are "K" and "V" respectively. * For now let's assume this should work. */ @Override public String containedTypeName(int index) { if (index == 0) return "K"; if (index == 1) return "V"; return null; } // TODO: should allow construction of instances that do refer // to parameterization, since it is NOT Map @Override public Class<?> getParameterSource() { return null; } @Override public StringBuilder getErasedSignature(StringBuilder sb) { return _classSignature(_class, sb, true); } @Override public StringBuilder getGenericSignature(StringBuilder sb) { _classSignature(_class, sb, false); sb.append('<'); _keyType.getGenericSignature(sb); _valueType.getGenericSignature(sb); sb.append(">;"); return sb; } /* /********************************************************** /* Extended API /********************************************************** */ public MapLikeType withKeyTypeHandler(Object h) { return new MapLikeType(_class, _keyType.withTypeHandler(h), _valueType, _valueHandler, _typeHandler, _asStatic); } public MapLikeType withKeyValueHandler(Object h) { return new MapLikeType(_class, _keyType.with

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>ValueHandler(h), _valueType, _valueHandler, _typeHandler, _asStatic); } /** * Method that can be used for checking whether this type is a * "real" Collection type; meaning whether it represents a parameterized * subtype of {@link java.util.Collection} or just something that acts * like one. */ public boolean isTrueMapType() { return Map.class.isAssignableFrom(_class); } /* /********************************************************** /* Standard methods /********************************************************** */ @Override public String toString() { return "[map-like type; class "+_class.getName()+", "+_keyType+" -> "+_valueType+"]"; } @Override public boolean equals(Object o) { if (o == this) return true; if (o == null) return false; if (o.getClass() != getClass()) return false; MapLikeType other = (MapLikeType) o; return (_class == other._class) && _keyType.equals(other._keyType) && _valueType.equals(other._valueType); } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>String> foundSoFar); public abstract List<JsonNode> findParents(String fieldName, List<JsonNode> foundSoFar); /* /********************************************************** /* Public API, path handling /********************************************************** */ /** * Method that can be called on Object nodes, to access a property * that has Object value; or if no such property exists, to create, * add and return such Object node. * If the node method is called on is not Object node, * or if property exists and has value that is not Object node, * {@link UnsupportedOperationException} is thrown */ public JsonNode with(String propertyName) { throw new UnsupportedOperationException("JsonNode not of type ObjectNode (but " +getClass().getName()+"), can not call with() on it"); } /** * Method that can be called on Object nodes, to access a property * that has <code>Array</code> value; or if no such property exists, to create, * add and return such Array node. * If the node method is called on is not Object node, * or if property exists and has value that is not Array node, * {@link UnsupportedOperationException} is thrown */ public JsonNode withArray(String propertyName) { throw new UnsupportedOperationException("JsonNode not of type ObjectNode (but " +getClass().getName()+"), can not call withArray() on it"); } /* /********************************************************** /* Overridden standard methods /********************************************************** */ /** *<p> * Note: marked as abstract to ensure all implementation * classes define it properly. */ @Override public abstract String toString(); /** * Equality for node objects is defined as full (deep) value * equality. This means that it is possible to compare complete * JSON trees for equality by comparing equality of root nodes. *<p> * Note: marked as abstract to ensure all implementation * classes define it properly and not rely on definition * from {@link java.lang.Object}. */ @Override public abstract boolean equals(Object o); }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.type; import java.lang.reflect.*; /** * Simple replacement for {@link java.lang.Class} (and/or various Type subtypes) * that is used as part of single-path extends/implements chain to express * specific relationship between one subtype and one supertype. This is needed * for resolving type parameters. Instances are doubly-linked so that chain * can be traversed in both directions */ public class HierarchicType { /** * Type which will be either plain {@link java.lang.Class} or * {@link java.lang.reflect.ParameterizedType}. */ protected final Type _actualType; protected final Class<?> _rawClass; protected final ParameterizedType _genericType; protected HierarchicType _superType; protected HierarchicType _subType; public HierarchicType(Type type) { this._actualType = type; if (type instanceof Class<?>) { _rawClass = (Class<?>) type; _genericType = null; } else if (type instanceof ParameterizedType) { _genericType = (ParameterizedType) type; _rawClass = (Class<?>) _genericType.getRawType(); } else { // should never happen... can't extend GenericArrayType? throw new IllegalArgumentException("Type "+type.getClass().getName()+" can not be used to construct HierarchicType"); } } private HierarchicType(Type actualType, Class<?> rawClass, ParameterizedType genericType, HierarchicType superType, HierarchicType subType) { _actualType = actualType; _rawClass = rawClass; _genericType = genericType; _superType = superType; _subType = subType; } /** * Method that can be used to create a deep clone of this hierarchic type, including * super types (but not subtypes) */ public HierarchicType deepCloneWithoutSubtype() { HierarchicType sup = (_superType == null) ? null : _superType.deepCloneWithoutSubtype(); HierarchicType result = new HierarchicType(_actualType, _rawClass, _genericType, sup, null); if (sup != null)

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.convert; import java.io.IOException; import java.util.*; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.JsonSerializer; import com.fasterxml.jackson.databind.SerializerProvider; import com.fasterxml.jackson.databind.annotation.JsonSerialize; import com.fasterxml.jackson.databind.util.StdConverter; public class TestConvertingSerializer extends com.fasterxml.jackson.databind.BaseMapTest { @JsonSerialize(converter=ConvertingBeanConverter.class) static class ConvertingBean { public int x, y; public ConvertingBean(int v1, int v2) { x = v1; y = v2; } } static class Point { public int x, y; public Point(int v1, int v2) { x = v1; y = v2; } } static class ConvertingBeanContainer { public List<ConvertingBean> values; public ConvertingBeanContainer(ConvertingBean... beans) { values = Arrays.asList(beans); } } static class ConvertingBeanConverter extends StdConverter<ConvertingBean, int[]> { @Override public int[] convert(ConvertingBean value) { return new int[] { value.x, value.y }; } } static class PointConverter extends StdConverter<Point, int[]> { @Override public int[] convert(Point value) { return new int[] { value.x, value.y }; } } static class PointWrapper { @JsonSerialize(converter=PointConverter.class) public Point value; public PointWrapper(int x, int y) { value = new Point(x, y); } } static class PointListWrapperArray { @JsonSerialize(contentConverter=PointConverter.class) public Point[] values; public PointListWrapperArray(int x, int y) { values = new Point[] { new Point(x, y), new Point(y, x) }; } } static class PointListWrapperList { @JsonSerialize(contentConverter=PointConverter.class) public List<Point> values; public

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> PointListWrapperList(int x, int y) { values = Arrays.asList(new Point[] { new Point(x, y), new Point(y, x) }); } } static class PointListWrapperMap { @JsonSerialize(contentConverter=PointConverter.class) public Map<String,Point> values; public PointListWrapperMap(String key, int x, int y) { values = new HashMap<String,Point>(); values.put(key, new Point(x, y)); } } // [Issue#359] static class Bean359 { @JsonSerialize(as = List.class, contentAs = Source.class) public List<Source> stuff = Arrays.asList(new Source()); } @JsonSerialize(using = TargetSerializer.class) static class Target { public String unexpected = "Bye."; } @JsonSerialize(converter = SourceToTargetConverter.class) static class Source { } static class SourceToTargetConverter extends StdConverter<Source, Target> { @Override public Target convert(Source value) { return new Target(); } } static class TargetSerializer extends JsonSerializer<Target> { @Override public void serialize(Target a, JsonGenerator jsonGenerator, SerializerProvider provider) throws IOException { jsonGenerator.writeString("Target"); } } // [Issue#731] public static class DummyBean { public final int a, b; public DummyBean(int v1, int v2) { a = v1 * 2; b = v2 * 2; } } @JsonSerialize(converter = UntypedConvertingBeanConverter.class) static class ConvertingBeanWithUntypedConverter { public int x, y; public ConvertingBeanWithUntypedConverter(int v1, int v2) { x = v1; y = v2; } } static class UntypedConvertingBeanConverter extends StdConverter<ConvertingBeanWithUntypedConverter, Object> { @Override public Object convert(ConvertingBeanWithUntypedConverter cb) { return new DummyBean(cb.x, cb.y); } } /* /********************************************************** /* Test methods /********************************************************** */

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std; import java.lang.reflect.Type; import java.io.IOException; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.annotation.JacksonStdImpl; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper; import com.fasterxml.jackson.databind.jsontype.TypeSerializer; /** * This is a simple dummy serializer that will just output literal * JSON null value whenever serialization is requested. * Used as the default "null serializer" (which is used for serializing * null object references unless overridden), as well as for some * more exotic types (java.lang.Void). */ @JacksonStdImpl @SuppressWarnings("serial") public class NullSerializer extends StdSerializer<Object> { public final static NullSerializer instance = new NullSerializer(); private NullSerializer() { super(Object.class); } @Override public void serialize(Object value, JsonGenerator gen, SerializerProvider provider) throws IOException { gen.writeNull(); } /** * Although this method should rarely get called, for convenience we should override * it, and handle it same way as "natural" types: by serializing exactly as is, * without type decorations. The most common possible use case is that of delegation * by JSON filter; caller can not know what kind of serializer it gets handed. */ @Override public void serializeWithType(Object value, JsonGenerator gen, SerializerProvider serializers, TypeSerializer typeSer) throws IOException { gen.writeNull(); } @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) throws JsonMappingException { return createSchemaNode("null"); } @Override public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException { visitor.expectNullFormat(typeHint); } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> foobar() { } } ,B { @Override public void foobar() { } } ; public abstract void foobar(); } protected BaseMapTest() { super(); } /* /********************************************************** /* Additional assert methods /********************************************************** */ private final static ObjectMapper SHARED_MAPPER = new ObjectMapper(); protected ObjectMapper objectMapper() { return SHARED_MAPPER; } protected ObjectWriter objectWriter() { return SHARED_MAPPER.writer(); } protected ObjectReader objectReader() { return SHARED_MAPPER.reader(); } protected ObjectReader objectReader(Class<?> cls) { return SHARED_MAPPER.reader(cls); } /* /********************************************************** /* Additional assert methods /********************************************************** */ protected void assertEquals(int[] exp, int[] act) { assertArrayEquals(exp, act); } /** * Helper method for verifying 3 basic cookie cutter cases; * identity comparison (true), and against null (false), * or object of different type (false) */ protected void assertStandardEquals(Object o) { assertTrue(o.equals(o)); assertFalse(o.equals(null)); assertFalse(o.equals(SINGLETON_OBJECT)); // just for fun, let's also call hash code... o.hashCode(); } /* /********************************************************** /* Helper methods, serialization /********************************************************** */ @SuppressWarnings("unchecked") protected Map<String,Object> writeAndMap(ObjectMapper m, Object value) throws IOException { String str = m.writeValueAsString(value); return (Map<String,Object>) m.readValue(str, Map.class); } protected String serializeAsString(ObjectMapper m, Object value) throws IOException { return m.writeValueAsString(value); } protected String serializeAsString(Object value) throws IOException { return serializeAsString(SHARED_MAPPER, value); } protected String asJSONObjectValueString(Object... args) throws IOException { return asJSONObjectValueString(SHARED_MAPPER, args); } protected String asJSONObjectValueString(ObjectMapper m, Object... args) throws IOException { LinkedHashMap<Object,Object> map = new LinkedHashMap<Object,Object>(); for (int i

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.impl; import java.io.IOException; import java.lang.reflect.Type; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.JavaType; import com.fasterxml.jackson.databind.JsonMappingException; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.SerializerProvider; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper; import com.fasterxml.jackson.databind.ser.std.StdSerializer; /** * Special bogus "serializer" that will throw * {@link JsonGenerationException} if its {@link #serialize} * gets invoked. Most commonly registered as handler for unknown types, * as well as for catching unintended usage (like trying to use null * as Map/Object key). */ @SuppressWarnings("serial") public class FailingSerializer extends StdSerializer<Object> { protected final String _msg; public FailingSerializer(String msg) { super(Object.class); _msg = msg; } @Override public void serialize(Object value, JsonGenerator jgen, SerializerProvider provider) throws IOException { throw new JsonGenerationException(_msg); } @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) throws JsonMappingException { return null; } @Override public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) { ; } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.type; import java.lang.reflect.Array; import com.fasterxml.jackson.databind.JavaType; /** * Array types represent Java arrays, both primitive and object valued. * Further, Object-valued arrays can have element type of any other * legal {@link JavaType}. */ public final class ArrayType extends TypeBase { private static final long serialVersionUID = 9040058063449087477L; /** * Type of elements in the array. */ protected final JavaType _componentType; /** * We will also keep track of shareable instance of empty array, * since it usually needs to be constructed any way; and because * it is essentially immutable and thus can be shared. */ protected final Object _emptyArray; private ArrayType(JavaType componentType, Object emptyInstance, Object valueHandler, Object typeHandler, boolean asStatic) { super(emptyInstance.getClass(), componentType.hashCode(), valueHandler, typeHandler, asStatic); _componentType = componentType; _emptyArray = emptyInstance; } public static ArrayType construct(JavaType componentType, Object valueHandler, Object typeHandler) { /* This is bit messy: there is apparently no other way to * reconstruct actual concrete/raw array class from component * type, than to construct an instance, get class (same is * true for GenericArracyType as well; hence we won't bother * passing that in). */ Object emptyInstance = Array.newInstance(componentType.getRawClass(), 0); return new ArrayType(componentType, emptyInstance, null, null, false); } @Override public ArrayType withTypeHandler(Object h) { if (h == _typeHandler) { return this; } return new ArrayType(_componentType, _emptyArray, _valueHandler, h, _asStatic); } @Override public ArrayType withContentTypeHandler(Object h) { if (h == _componentType.<Object>getTypeHandler()) { return this; } return new ArrayType(_componentType.withTypeHandler(h), _emptyArray, _valueHandler, _

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>typeHandler, _asStatic); } @Override public ArrayType withValueHandler(Object h) { if (h == _valueHandler) { return this; } return new ArrayType(_componentType, _emptyArray, h, _typeHandler,_asStatic); } @Override public ArrayType withContentValueHandler(Object h) { if (h == _componentType.<Object>getValueHandler()) { return this; } return new ArrayType(_componentType.withValueHandler(h), _emptyArray, _valueHandler, _typeHandler, _asStatic); } @Override public ArrayType withStaticTyping() { if (_asStatic) { return this; } return new ArrayType(_componentType.withStaticTyping(), _emptyArray, _valueHandler, _typeHandler, true); } @Override protected String buildCanonicalName() { return _class.getName(); } /* /********************************************************** /* Methods for narrowing conversions /********************************************************** */ /** * Handling of narrowing conversions for arrays is trickier: for now, * it is not even allowed. */ @Override protected JavaType _narrow(Class<?> subclass) { /* Ok: need a bit of indirection here. First, must replace component * type (and check that it is compatible), then re-construct. */ if (!subclass.isArray()) { // sanity check, should never occur throw new IllegalArgumentException("Incompatible narrowing operation: trying to narrow "+toString()+" to class "+subclass.getName()); } /* Hmmh. This is an awkward back reference... but seems like the * only simple way to do it. */ Class<?> newCompClass = subclass.getComponentType(); /* 14-Mar-2011, tatu: it gets even worse, as we do not have access to * currently configured TypeFactory. This could theoretically cause * problems (when narrowing from array of Objects, to array of non-standard * Maps, for example); but for now need to defer solving this until * it actually becomes a real problem, not just potential one. * (famous last words?) */ JavaType newCompType = TypeFactory.defaultInstance().constructType(new

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> } @Override public JavaType getContentType() { return _componentType; } @Override public int containedTypeCount() { return 1; } @Override public JavaType containedType(int index) { return (index == 0) ? _componentType : null; } @Override public StringBuilder getGenericSignature(StringBuilder sb) { sb.append('['); return _componentType.getGenericSignature(sb); } @Override public StringBuilder getErasedSignature(StringBuilder sb) { sb.append('['); return _componentType.getErasedSignature(sb); } /* /********************************************************** /* Standard methods /********************************************************** */ @Override public String toString() { return "[array type, component type: "+_componentType+"]"; } @Override public boolean equals(Object o) { if (o == this) return true; if (o == null) return false; if (o.getClass() != getClass()) return false; ArrayType other = (ArrayType) o; return _componentType.equals(other._componentType); } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.annotation; import java.lang.annotation.*; import com.fasterxml.jackson.databind.PropertyNamingStrategy; /** * Annotation that can be used to indicate a {@link PropertyNamingStrategy} * to use for annotated class. Overrides the global (default) strategy. * * @since 2.1 */ @Target({ElementType.ANNOTATION_TYPE, ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @com.fasterxml.jackson.annotation.JacksonAnnotation public @interface JsonNaming { /** * @return Type of {@link PropertyNamingStrategy} to use, if any; default value of * <code>PropertyNamingStrategy.class</code> means "no strategy specified" * (and may also be used for overriding to remove otherwise applicable * naming strategy) */ public Class<? extends PropertyNamingStrategy> value() default PropertyNamingStrategy.class; }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>member = member; _contextAnnotations = contextAnnotations; } @Deprecated // since 2.3 public Std(String name, JavaType type, PropertyName wrapperName, Annotations contextAnnotations, AnnotatedMember member, boolean isRequired) { this(new PropertyName(name), type, wrapperName, contextAnnotations, member, isRequired ? PropertyMetadata.STD_REQUIRED : PropertyMetadata.STD_OPTIONAL); } public Std withType(JavaType type) { return new Std(_name, type, _wrapperName, _contextAnnotations, _member, _metadata); } @Override public <A extends Annotation> A getAnnotation(Class<A> acls) { return (_member == null) ? null : _member.getAnnotation(acls); } @Override public <A extends Annotation> A getContextAnnotation(Class<A> acls) { return (_contextAnnotations == null) ? null : _contextAnnotations.get(acls); } @Override public String getName() { return _name.getSimpleName(); } @Override public PropertyName getFullName() { return _name; } @Override public JavaType getType() { return _type; } @Override public PropertyName getWrapperName() { return _wrapperName; } @Override public boolean isRequired() { return _metadata.isRequired(); } @Override public PropertyMetadata getMetadata() { return _metadata; } @Override public AnnotatedMember getMember() { return _member; } /** *<p> * TODO: move to {@link BeanProperty} in near future, once all standard * implementations define it. * * @since 2.5 */ public boolean isVirtual() { return false; } /** * Implementation of this method throws * {@link UnsupportedOperationException}, since instances of this * implementation should not be used as part of actual structure * visited. Rather, other implementations should handle it. */ @Override public void depositSchemaProperty(JsonObjectFormatVisitor objectVisitor) { throw new UnsupportedOperationException("Instances of "+getClass().getName()+" should not get visited"); } } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> = src._injectableValueId; _fallbackSetter = src._fallbackSetter; } /** * @since 2.3 */ protected CreatorProperty(CreatorProperty src, SettableBeanProperty fallbackSetter) { super(src); _annotated = src._annotated; _creatorIndex = src._creatorIndex; _injectableValueId = src._injectableValueId; _fallbackSetter = fallbackSetter; } @Override public CreatorProperty withName(PropertyName newName) { return new CreatorProperty(this, newName); } @Override public CreatorProperty withValueDeserializer(JsonDeserializer<?> deser) { return new CreatorProperty(this, deser); } public CreatorProperty withFallbackSetter(SettableBeanProperty fallbackSetter) { return new CreatorProperty(this, fallbackSetter); } /** * Method that can be called to locate value to be injected for this * property, if it is configured for this. */ public Object findInjectableValue(DeserializationContext context, Object beanInstance) { if (_injectableValueId == null) { throw new IllegalStateException("Property '"+getName() +"' (type "+getClass().getName()+") has no injectable value id configured"); } return context.findInjectableValue(_injectableValueId, this, beanInstance); } /** * Method to find value to inject, and inject it to this property. */ public void inject(DeserializationContext context, Object beanInstance) throws IOException { set(beanInstance, findInjectableValue(context, beanInstance)); } /* /********************************************************** /* BeanProperty impl /********************************************************** */ @Override public <A extends Annotation> A getAnnotation(Class<A> acls) { if (_annotated == null) { return null; } return _annotated.getAnnotation(acls); } @Override public AnnotatedMember getMember() { return _annotated; } @Override public int getCreatorIndex() { return _creatorIndex; } /* /********************************************************** /* Overridden methods /********************************************************** */ @Override public void deserializeAndSet(JsonParser jp, DeserializationContext ctxt, Object instance) throws IOException, JsonProcessingException { set(instance, deserialize(jp, ctxt)); } @Override

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> public Object deserializeSetAndReturn(JsonParser jp, DeserializationContext ctxt, Object instance) throws IOException, JsonProcessingException { return setAndReturn(instance, deserialize(jp, ctxt)); } @Override public void set(Object instance, Object value) throws IOException { /* Hmmmh. Should we return quietly (NOP), or error? * Perhaps better to throw an exception, since it's generally an error. */ if (_fallbackSetter == null) { throw new IllegalStateException("No fallback setter/field defined: can not use creator property for " +getClass().getName()); } _fallbackSetter.set(instance, value); } @Override public Object setAndReturn(Object instance, Object value) throws IOException { if (_fallbackSetter == null) { throw new IllegalStateException("No fallback setter/field defined: can not use creator property for " +getClass().getName()); } return _fallbackSetter.setAndReturn(instance, value); } @Override public Object getInjectableValueId() { return _injectableValueId; } @Override public String toString() { return "[creator property, name '"+getName()+"'; inject id '"+_injectableValueId+"']"; } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> annotated, implClass); if (gen == null) { gen = (ObjectIdGenerator<?>) ClassUtil.createInstance(implClass, config.canOverrideAccessModifiers()); } return gen.forScope(objectIdInfo.getScope()); } public ObjectIdResolver objectIdResolverInstance(Annotated annotated, ObjectIdInfo objectIdInfo) { Class<? extends ObjectIdResolver> implClass = objectIdInfo.getResolverType(); final MapperConfig<?> config = getConfig(); HandlerInstantiator hi = config.getHandlerInstantiator(); ObjectIdResolver resolver = (hi == null) ? null : hi.resolverIdGeneratorInstance(config, annotated, implClass); if (resolver == null) { resolver = ClassUtil.createInstance(implClass, config.canOverrideAccessModifiers()); } return resolver; } /** * Helper method to use to construct a {@link Converter}, given a definition * that may be either actual converter instance, or Class for instantiating one. * * @since 2.2 */ @SuppressWarnings("unchecked") public Converter<Object,Object> converterInstance(Annotated annotated, Object converterDef) throws JsonMappingException { if (converterDef == null) { return null; } if (converterDef instanceof Converter<?,?>) { return (Converter<Object,Object>) converterDef; } if (!(converterDef instanceof Class)) { throw new IllegalStateException("AnnotationIntrospector returned Converter definition of type " +converterDef.getClass().getName()+"; expected type Converter or Class<Converter> instead"); } Class<?> converterClass = (Class<?>)converterDef; // there are some known "no class" markers to consider too: if (converterClass == Converter.None.class || ClassUtil.isBogusClass(converterClass)) { return null; } if (!Converter.class.isAssignableFrom(converterClass)) { throw new IllegalStateException("AnnotationIntrospector returned Class " +converterClass.getName()+"; expected Class<Converter>"); } final MapperConfig<?> config = getConfig(); HandlerInstantiator hi = config.getHandlerInstantiator(); Converter<?,?> conv = (hi == null) ? null : hi.converterInstance(config, annotated, converterClass); if (conv == null) { conv = (Converter<?,?>) ClassUtil.create

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std; import java.io.IOException; import java.lang.reflect.Type; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.JavaType; import com.fasterxml.jackson.databind.JsonMappingException; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.SerializerProvider; import com.fasterxml.jackson.databind.annotation.JacksonStdImpl; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper; import com.fasterxml.jackson.databind.jsontype.TypeSerializer; /** * Simple general purpose serializer, useful for any * type for which {@link Object#toString} returns the desired JSON * value. */ @JacksonStdImpl @SuppressWarnings("serial") public class ToStringSerializer extends StdSerializer<Object> { /** * Singleton instance to use. */ public final static ToStringSerializer instance = new ToStringSerializer(); /** *<p> * Note: usually you should NOT create new instances, but instead use * {@link #instance} which is stateless and fully thread-safe. However, * there are cases where constructor is needed; for example, * when using explicit serializer annotations like * {@link com.fasterxml.jackson.databind.annotation.JsonSerialize#using}. */ public ToStringSerializer() { super(Object.class); } /** * Sometimes it may actually make sense to retain actual handled type, so... * * @since 2.5 */ public ToStringSerializer(Class<?> handledType) { super(handledType, false); } @Override @Deprecated public boolean isEmpty(Object value) { return isEmpty(null, value); } @Override public boolean isEmpty(SerializerProvider prov, Object value) { if (value == null) { return true; } String str = value.toString(); return str.isEmpty(); } @Override public void serialize(Object value, JsonGenerator gen, SerializerProvider provider) throws IOException { gen.writeString(value.toString()); } /* 01-Mar-2011, tatu: We were serializing as "raw" String; but

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> super(Object[].class, null); _elementType = elemType; _staticTyping = staticTyping; _valueTypeSerializer = vts; _dynamicSerializers = PropertySerializerMap.emptyForProperties(); _elementSerializer = elementSerializer; } public ObjectArraySerializer(ObjectArraySerializer src, TypeSerializer vts) { super(src); _elementType = src._elementType; _valueTypeSerializer = vts; _staticTyping = src._staticTyping; _dynamicSerializers = src._dynamicSerializers; _elementSerializer = src._elementSerializer; } @SuppressWarnings("unchecked") public ObjectArraySerializer(ObjectArraySerializer src, BeanProperty property, TypeSerializer vts, JsonSerializer<?> elementSerializer) { super(src, property); _elementType = src._elementType; _valueTypeSerializer = vts; _staticTyping = src._staticTyping; _dynamicSerializers = src._dynamicSerializers; _elementSerializer = (JsonSerializer<Object>) elementSerializer; } @Override public ContainerSerializer<?> _withValueTypeSerializer(TypeSerializer vts) { return new ObjectArraySerializer(_elementType, _staticTyping, vts, _elementSerializer); } public ObjectArraySerializer withResolved(BeanProperty prop, TypeSerializer vts, JsonSerializer<?> ser) { if (_property == prop && ser == _elementSerializer && _valueTypeSerializer == vts) { return this; } return new ObjectArraySerializer(this, prop, vts, ser); } /* /********************************************************** /* Post-processing /********************************************************** */ @Override public JsonSerializer<?> createContextual(SerializerProvider provider, BeanProperty property) throws JsonMappingException { TypeSerializer vts = _valueTypeSerializer; if (vts != null) { vts = vts.forProperty(property); } /* 29-Sep-2012, tatu: Actually, we need to do much more contextual * checking here since we finally know for sure the property, * and it may have overrides */ JsonSerializer<?> ser = null; // First: if we have a property, may have property-annotation overrides if (property != null) { AnnotatedMember m = property.getMember(); if (m != null

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> if (_elementSerializer != null) { serializeContentsUsing(value, jgen, provider, _elementSerializer); return; } if (_valueTypeSerializer != null) { serializeTypedContents(value, jgen, provider); return; } int i = 0; Object elem = null; try { PropertySerializerMap serializers = _dynamicSerializers; for (; i < len; ++i) { elem = value[i]; if (elem == null) { provider.defaultSerializeNull(jgen); continue; } Class<?> cc = elem.getClass(); JsonSerializer<Object> serializer = serializers.serializerFor(cc); if (serializer == null) { // To fix [JACKSON-508] if (_elementType.hasGenericTypes()) { serializer = _findAndAddDynamic(serializers, provider.constructSpecializedType(_elementType, cc), provider); } else { serializer = _findAndAddDynamic(serializers, cc, provider); } } serializer.serialize(elem, jgen, provider); } } catch (IOException ioe) { throw ioe; } catch (Exception e) { // [JACKSON-55] Need to add reference information /* 05-Mar-2009, tatu: But one nasty edge is when we get * StackOverflow: usually due to infinite loop. But that gets * hidden within an InvocationTargetException... */ Throwable t = e; while (t instanceof InvocationTargetException && t.getCause() != null) { t = t.getCause(); } if (t instanceof Error) { throw (Error) t; } throw JsonMappingException.wrapWithPath(t, elem, i); } } public void serializeContentsUsing(Object[] value, JsonGenerator jgen, SerializerProvider provider, JsonSerializer<Object> ser) throws IOException { final int len = value.length; final TypeSerializer typeSer = _valueTypeSerializer; int i = 0; Object elem = null; try { for (; i < len; ++i) { elem = value[i]; if (elem == null) { provider.defaultSerializeNull(jgen); continue; } if (type

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>Ser == null) { ser.serialize(elem, jgen, provider); } else { ser.serializeWithType(elem, jgen, provider, typeSer); } } } catch (IOException ioe) { throw ioe; } catch (Exception e) { Throwable t = e; while (t instanceof InvocationTargetException && t.getCause() != null) { t = t.getCause(); } if (t instanceof Error) { throw (Error) t; } throw JsonMappingException.wrapWithPath(t, elem, i); } } public void serializeTypedContents(Object[] value, JsonGenerator jgen, SerializerProvider provider) throws IOException { final int len = value.length; final TypeSerializer typeSer = _valueTypeSerializer; int i = 0; Object elem = null; try { PropertySerializerMap serializers = _dynamicSerializers; for (; i < len; ++i) { elem = value[i]; if (elem == null) { provider.defaultSerializeNull(jgen); continue; } Class<?> cc = elem.getClass(); JsonSerializer<Object> serializer = serializers.serializerFor(cc); if (serializer == null) { serializer = _findAndAddDynamic(serializers, cc, provider); } serializer.serializeWithType(elem, jgen, provider, typeSer); } } catch (IOException ioe) { throw ioe; } catch (Exception e) { Throwable t = e; while (t instanceof InvocationTargetException && t.getCause() != null) { t = t.getCause(); } if (t instanceof Error) { throw (Error) t; } throw JsonMappingException.wrapWithPath(t, elem, i); } } @SuppressWarnings("deprecation") @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) throws JsonMappingException { ObjectNode o = createSchemaNode("array", true); if (typeHint != null) { JavaType javaType = provider.constructType(typeHint); if (javaType.isArrayType()) { Class<?> componentType = ((ArrayType) javaType).getContentType().getRawClass(); // 15-Oct-2010

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>, tatu: We can't serialize plain Object.class; but what should it produce here? Untyped? if (componentType == Object.class) { o.put("items", com.fasterxml.jackson.databind.jsonschema.JsonSchema.getDefaultSchemaNode()); } else { JsonSerializer<Object> ser = provider.findValueSerializer(componentType, _property); JsonNode schemaNode = (ser instanceof SchemaAware) ? ((SchemaAware) ser).getSchema(provider, null) : com.fasterxml.jackson.databind.jsonschema.JsonSchema.getDefaultSchemaNode(); o.put("items", schemaNode); } } } return o; } @Override public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException { JsonArrayFormatVisitor arrayVisitor = visitor.expectArrayFormat(typeHint); if (arrayVisitor != null) { TypeFactory tf = visitor.getProvider().getTypeFactory(); JavaType contentType = tf.moreSpecificType(_elementType, typeHint.getContentType()); if (contentType == null) { throw new JsonMappingException("Could not resolve type"); } JsonSerializer<?> valueSer = _elementSerializer; if (valueSer == null) { valueSer = visitor.getProvider().findValueSerializer(contentType, _property); } arrayVisitor.itemsFormat(valueSer, contentType); } } protected final JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap map, Class<?> type, SerializerProvider provider) throws JsonMappingException { PropertySerializerMap.SerializerAndMapResult result = map.findAndAddSecondarySerializer(type, provider, _property); // did we get a new map of serializers? If so, start using it if (map != result.map) { _dynamicSerializers = result.map; } return result.serializer; } protected final JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap map, JavaType type, SerializerProvider provider) throws JsonMappingException { PropertySerializerMap.SerializerAndMapResult result = map.findAndAddSecondarySerializer(type, provider, _property); // did we get a new map of serializers? If so, start using it if (map != result.map) { _dynamic

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std; import java.io.IOException; import java.lang.reflect.Type; import java.util.Map; import com.fasterxml.jackson.annotation.JsonFormat; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.annotation.JacksonStdImpl; import com.fasterxml.jackson.databind.introspect.AnnotatedMember; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonIntegerFormatVisitor; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonNumberFormatVisitor; import com.fasterxml.jackson.databind.jsontype.TypeSerializer; import com.fasterxml.jackson.databind.ser.ContextualSerializer; /** * Container class for serializers used for handling standard JDK-provided types. */ @SuppressWarnings("serial") public class NumberSerializers { protected NumberSerializers() { } public static void addAll(Map<String, JsonSerializer<?>> allDeserializers) { final JsonSerializer<?> intS = new IntegerSerializer(); allDeserializers.put(Integer.class.getName(), intS); allDeserializers.put(Integer.TYPE.getName(), intS); allDeserializers.put(Long.class.getName(), LongSerializer.instance); allDeserializers.put(Long.TYPE.getName(), LongSerializer.instance); allDeserializers.put(Byte.class.getName(), IntLikeSerializer.instance); allDeserializers.put(Byte.TYPE.getName(), IntLikeSerializer.instance); allDeserializers.put(Short.class.getName(), ShortSerializer.instance); allDeserializers.put(Short.TYPE.getName(), ShortSerializer.instance); // Numbers, limited length floating point allDeserializers.put(Float.class.getName(), FloatSerializer.instance); allDeserializers.put(Float.TYPE.getName(), FloatSerializer.instance); allDeserializers.put(Double.class.getName(), DoubleSerializer.instance); allDeserializers.put(Double.TYPE.getName(), DoubleSerializer.instance); } /* /********************************************************** /* Shared base class /********************************************************** */

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> protected abstract static class Base<T> extends StdScalarSerializer<T> implements ContextualSerializer { protected final JsonParser.NumberType _numberType; protected final String _schemaType; protected final boolean _isInt; protected Base(Class<T> cls, JsonParser.NumberType numberType, String schemaType) { super(cls); _numberType = numberType; _schemaType = schemaType; _isInt = (numberType == JsonParser.NumberType.INT) || (numberType == JsonParser.NumberType.LONG) || (numberType == JsonParser.NumberType.BIG_INTEGER) ; } @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) { return createSchemaNode(_schemaType, true); } @Override public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException { if (_isInt) { JsonIntegerFormatVisitor v2 = visitor.expectIntegerFormat(typeHint); if (v2 != null) { v2.numberType(_numberType); } } else { JsonNumberFormatVisitor v2 = visitor.expectNumberFormat(typeHint); if (v2 != null) { v2.numberType(_numberType); } } } @Override public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty property) throws JsonMappingException { if (property != null) { AnnotatedMember m = property.getMember(); if (m != null) { JsonFormat.Value format = prov.getAnnotationIntrospector().findFormat(m); if (format != null) { switch (format.getShape()) { case STRING: return ToStringSerializer.instance; default: } } } } return this; } } /* /********************************************************** /* Concrete serializers, numerics /********************************************************** */ @JacksonStdImpl public final static class ShortSerializer extends Base<Short> { final static ShortSerializer instance = new ShortSerializer(); public ShortSerializer() { super(Short.class, JsonParser.NumberType.INT, "number"); } @Override public void serialize(Short value, JsonGenerator jgen, SerializerProvider provider) throws IOException

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> { jgen.writeNumber(value.shortValue()); } } /** * This is the special serializer for regular {@link java.lang.Integer}s * (and primitive ints) *<p> * Since this is one of "native" types, no type information is ever * included on serialization (unlike for most scalar types as of 1.5) */ @JacksonStdImpl public final static class IntegerSerializer extends Base<Integer> { public IntegerSerializer() { super(Integer.class, JsonParser.NumberType.INT ,"integer"); } @Override public void serialize(Integer value, JsonGenerator jgen, SerializerProvider provider) throws IOException { jgen.writeNumber(value.intValue()); } // IMPORTANT: copied from `NonTypedScalarSerializerBase` @Override public void serializeWithType(Integer value, JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer) throws IOException { // no type info, just regular serialization serialize(value, jgen, provider); } } /** * Similar to {@link IntegerSerializer}, but will not cast to Integer: * instead, cast is to {@link java.lang.Number}, and conversion is * by calling {@link java.lang.Number#intValue}. */ @JacksonStdImpl public final static class IntLikeSerializer extends Base<Number> { final static IntLikeSerializer instance = new IntLikeSerializer(); public IntLikeSerializer() { super(Number.class, JsonParser.NumberType.INT, "integer"); } @Override public void serialize(Number value, JsonGenerator jgen, SerializerProvider provider) throws IOException { jgen.writeNumber(value.intValue()); } } @JacksonStdImpl public final static class LongSerializer extends Base<Long> { final static LongSerializer instance = new LongSerializer(); public LongSerializer() { super(Long.class, JsonParser.NumberType.LONG, "number"); } @Override public void serialize(Long value, JsonGenerator jgen, SerializerProvider provider) throws IOException { jgen.writeNumber(value.longValue()); } } @JacksonStdImpl public final static class FloatSerializer extends Base<Float> { final static FloatSerializer instance = new FloatSerializer();

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> public FloatSerializer() { super(Float.class, JsonParser.NumberType.FLOAT, "number"); } @Override public void serialize(Float value, JsonGenerator jgen, SerializerProvider provider) throws IOException { jgen.writeNumber(value.floatValue()); } } /** * This is the special serializer for regular {@link java.lang.Double}s * (and primitive doubles) *<p> * Since this is one of "native" types, no type information is ever * included on serialization (unlike for most scalar types as of 1.5) */ @JacksonStdImpl public final static class DoubleSerializer extends Base<Double> { final static DoubleSerializer instance = new DoubleSerializer(); public DoubleSerializer() { super(Double.class, JsonParser.NumberType.DOUBLE, "number"); } @Override public void serialize(Double value, JsonGenerator jgen, SerializerProvider provider) throws IOException { jgen.writeNumber(value.doubleValue()); } // IMPORTANT: copied from `NonTypedScalarSerializerBase` @Override public void serializeWithType(Double value, JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer) throws IOException { // no type info, just regular serialization serialize(value, jgen, provider); } } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; import com.fasterxml.jackson.databind.JsonDeserializer; import com.fasterxml.jackson.databind.KeyDeserializer; import com.fasterxml.jackson.databind.util.Converter; /** * Annotation use for configuring deserialization aspects, by attaching * to "setter" methods or fields, or to value classes. * When annotating value classes, configuration is used for instances * of the value class but can be overridden by more specific annotations * (ones that attach to methods or fields). *<p> * An example annotation would be: *<pre> * &#64;JsonDeserialize(using=MySerializer.class, * as=MyHashMap.class, * keyAs=MyHashKey.class, * contentAs=MyHashValue.class * ) *</pre> *<p> */ @Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD, ElementType.FIELD, ElementType.TYPE, ElementType.PARAMETER}) @Retention(RetentionPolicy.RUNTIME) @com.fasterxml.jackson.annotation.JacksonAnnotation public @interface JsonDeserialize { // // // Annotations for explicitly specifying deserialize/builder /** * Deserializer class to use for deserializing associated value. * Depending on what is annotated, * value is either an instance of annotated class (used globablly * anywhere where class deserializer is needed); or only used for * deserializing property access via a setter method. */ public Class<? extends JsonDeserializer<?>> using() default JsonDeserializer.None.class; /** * Deserializer class to use for deserializing contents (elements * of a Collection/array, values of Maps) of annotated property. * Can only be used on instances (methods, fields, constructors), * and not value classes themselves. */ public Class<? extends JsonDeserializer<?>> contentUsing() default JsonDeserializer.None.class; /** * Deserializer class to use for deserializing Map keys * of annotated property. * Can only be used on instances (methods, fields, constructors),

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> * and not value classes themselves. */ public Class<? extends KeyDeserializer> keyUsing() default KeyDeserializer.None.class; /** * Annotation for specifying if an external Builder class is to * be used for building up deserialized instances of annotated * class. If so, an instance of referenced class is first constructed * (possibly using a Creator method; or if none defined, using default * constructor), and its "with-methods" are used for populating fields; * and finally "build-method" is invoked to complete deserialization. */ public Class<?> builder() default Void.class; // // // Annotations for specifying intermediate Converters (2.2+) /** * Which helper object (if any) is to be used to convert from Jackson-bound * intermediate type (source type of converter) into actual property type * (which must be same as result type of converter). This is often used * for two-step deserialization; Jackson binds data into suitable intermediate * type (like Tree representation), and converter then builds actual property * type. * * @since 2.2 */ public Class<? extends Converter<?,?>> converter() default Converter.None.class; /** * Similar to {@link #converter}, but used for values of structures types * (List, arrays, Maps). * * @since 2.2 */ public Class<? extends Converter<?,?>> contentConverter() default Converter.None.class; // // // Annotations for explicitly specifying deserialization type // // // (which is used for choosing deserializer, if not explicitly // // // specified /** * Concrete type to deserialize values as, instead of type otherwise * declared. Must be a subtype of declared type; otherwise an * exception may be thrown by deserializer. *<p> * Bogus type {@link Void} can be used to indicate that declared * type is used as is (i.e. this annotation property has no setting); * this since annotation properties are not allowed to have null value. *<p> * Note: if {@link #using} is also used it has precedence * (since it directly specified * deserializer, whereas this would only be used to locate the * deserializer) * and value of this annotation property is ignored.

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> */ public Class<?> as() default Void.class; /** * Concrete type to deserialize keys of {@link java.util.Map} as, * instead of type otherwise declared. * Must be a subtype of declared type; otherwise an exception may be * thrown by deserializer. */ public Class<?> keyAs() default Void.class; /** * Concrete type to deserialize content (elements * of a Collection/array, values of Maps) values as, * instead of type otherwise declared. * Must be a subtype of declared type; otherwise an exception may be * thrown by deserializer. */ public Class<?> contentAs() default Void.class; }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser.std; import java.io.IOException; import com.fasterxml.jackson.core.JsonParser; import com.fasterxml.jackson.databind.DeserializationContext; import com.fasterxml.jackson.databind.annotation.JacksonStdImpl; import com.fasterxml.jackson.databind.util.TokenBuffer; /** * We also want to directly support deserialization of {@link TokenBuffer}. *<p> * Note that we use scalar deserializer base just because we claim * to be of scalar for type information inclusion purposes; actual * underlying content can be of any (Object, Array, scalar) type. *<p> * Since 2.3, another important thing is that possible native ids * (type id, object id) should be properly copied even when converting * with {@link TokenBuffer}. Such ids are supported if (and only if!) * source {@link JsonParser} supports them. */ @JacksonStdImpl public class TokenBufferDeserializer extends StdScalarDeserializer<TokenBuffer> { private static final long serialVersionUID = 1L; public TokenBufferDeserializer() { super(TokenBuffer.class); } @Override public TokenBuffer deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException { return createBufferInstance(jp).deserialize(jp, ctxt); } protected TokenBuffer createBufferInstance(JsonParser jp) { return new TokenBuffer(jp); } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.type; /** * Key class, used as an efficient and accurate key * for locating per-class values, such as * {@link com.fasterxml.jackson.databind.JsonSerializer}s. *<p> * The reason for having a separate key class instead of * directly using {@link Class} as key is mostly * to allow for redefining <code>hashCode</code> method -- * for some strange reason, {@link Class} does not * redefine {@link Object#hashCode} and thus uses identity * hash, which is pretty slow. This makes key access using * {@link Class} unnecessarily slow. *<p> * Note: since class is not strictly immutable, caller must * know what it is doing, if changing field values. */ public final class ClassKey implements Comparable<ClassKey>, java.io.Serializable // since 2.1 { private static final long serialVersionUID = 1L; private String _className; private Class<?> _class; /** * Let's cache hash code straight away, since we are * almost certain to need it. */ private int _hashCode; public ClassKey() { _class = null; _className = null; _hashCode = 0; } public ClassKey(Class<?> clz) { _class = clz; _className = clz.getName(); _hashCode = _className.hashCode(); } public void reset(Class<?> clz) { _class = clz; _className = clz.getName(); _hashCode = _className.hashCode(); } /* /********************************************************** /* Comparable /********************************************************** */ @Override public int compareTo(ClassKey other) { // Just need to sort by name, ok to collide (unless used in TreeMap/Set!) return _className.compareTo(other._className); } /* /********************************************************** /* Standard methods /********************************************************** */ @Override public boolean equals(Object o) { if (o == this) return true; if (o == null) return false; if (o.getClass() != getClass()) return false; ClassKey other = (ClassKey)

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> o; /* Is it possible to have different Class object for same name + class loader combo? * Let's assume answer is no: if this is wrong, will need to uncomment following functionality */ /* return (other._className.equals(_className)) && (other._class.getClassLoader() == _class.getClassLoader()); */ return other._class == _class; } @Override public int hashCode() { return _hashCode; } @Override public String toString() { return _className; } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>** */ protected JsonDeserializer<Object> _mapDeserializer; protected JsonDeserializer<Object> _listDeserializer; protected JsonDeserializer<Object> _stringDeserializer; protected JsonDeserializer<Object> _numberDeserializer; public UntypedObjectDeserializer() { super(Object.class); } @SuppressWarnings("unchecked") public UntypedObjectDeserializer(UntypedObjectDeserializer base, JsonDeserializer<?> mapDeser, JsonDeserializer<?> listDeser, JsonDeserializer<?> stringDeser, JsonDeserializer<?> numberDeser) { super(Object.class); _mapDeserializer = (JsonDeserializer<Object>) mapDeser; _listDeserializer = (JsonDeserializer<Object>) listDeser; _stringDeserializer = (JsonDeserializer<Object>) stringDeser; _numberDeserializer = (JsonDeserializer<Object>) numberDeser; } /* /********************************************************** /* Initialization /********************************************************** */ /** * We need to implement this method to properly find things to delegate * to: it can not be done earlier since delegated deserializers almost * certainly require access to this instance (at least "List" and "Map" ones) */ @SuppressWarnings("unchecked") @Override public void resolve(DeserializationContext ctxt) throws JsonMappingException { JavaType obType = ctxt.constructType(Object.class); JavaType stringType = ctxt.constructType(String.class); TypeFactory tf = ctxt.getTypeFactory(); /* 26-Nov-2014, tatu: This is highly unusual, as in general contextualization * should always be called separately, from within "createContextual()". * But this is a very singular deserializer since it operates on `Object` * (and often for `?` type parameter), and as a result, easily and commonly * results in cycles, being value deserializer for various Maps and Collections. * Because of this, we must somehow break the cycles. This is done here by * forcing pseudo-contextualization with null property. */ // So: first find possible custom instances _mapDeserializer = _findCustomDeser(ctxt, tf.constructMapType(Map.class, stringType, obType)); _listDeserializer = _findCustomDeser(ctxt, tf.constructCollectionType(

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>List.class, obType)); _stringDeserializer = _findCustomDeser(ctxt, stringType); _numberDeserializer = _findCustomDeser(ctxt, tf.constructType(Number.class)); // and then do bogus contextualization, in case custom ones need to resolve dependencies of // their own JavaType unknown = TypeFactory.unknownType(); _mapDeserializer = (JsonDeserializer<Object>) ctxt.handleSecondaryContextualization(_mapDeserializer, null, unknown); _listDeserializer = (JsonDeserializer<Object>) ctxt.handleSecondaryContextualization(_listDeserializer, null, unknown); _stringDeserializer = (JsonDeserializer<Object>) ctxt.handleSecondaryContextualization(_stringDeserializer, null, unknown); _numberDeserializer = (JsonDeserializer<Object>) ctxt.handleSecondaryContextualization(_numberDeserializer, null, unknown); } @SuppressWarnings("unchecked") protected JsonDeserializer<Object> _findCustomDeser(DeserializationContext ctxt, JavaType type) throws JsonMappingException { // Since we are calling from `resolve`, we should NOT try to contextualize yet; // contextualization will only occur at a later point JsonDeserializer<?> deser = ctxt.findNonContextualValueDeserializer(type); if (ClassUtil.isJacksonStdImpl(deser)) { return null; } return (JsonDeserializer<Object>) deser; } /** * We only use contextualization for optimizing the case where no customization * occurred; if so, can slip in a more streamlined version. */ @Override public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException { // 20-Apr-2014, tatu: If nothing custom, let's use "vanilla" instance, // simpler and can avoid some of delegation if ((_stringDeserializer == null) && (_numberDeserializer == null) && (_mapDeserializer == null) && (_listDeserializer == null) && getClass() == UntypedObjectDeserializer.class) { return Vanilla.std; } return this; } protected JsonDeserializer<?> _withResolved(JsonDeserializer<?> mapDeser, JsonDeserializer<?> listDeser, JsonDeserializer<?> stringDeser, JsonDeserializer<?> numberDeser) { return

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> optimal, whatever it is case VALUE_NUMBER_FLOAT: if (_numberDeserializer != null) { return _numberDeserializer.deserialize(jp, ctxt); } /* [JACKSON-72]: need to allow overriding the behavior regarding * which type to use */ if (ctxt.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)) { return jp.getDecimalValue(); } return Double.valueOf(jp.getDoubleValue()); case VALUE_TRUE: return Boolean.TRUE; case VALUE_FALSE: return Boolean.FALSE; case VALUE_NULL: // should not get this but... return null; case END_ARRAY: // invalid case END_OBJECT: // invalid default: throw ctxt.mappingException(Object.class); } } @Override public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException { JsonToken t = jp.getCurrentToken(); switch (t) { // First: does it look like we had type id wrapping of some kind? case START_ARRAY: case START_OBJECT: case FIELD_NAME: /* Output can be as JSON Object, Array or scalar: no way to know * a this point: */ return typeDeserializer.deserializeTypedFromAny(jp, ctxt); /* Otherwise we probably got a "native" type (ones that map * naturally and thus do not need or use type ids) */ case VALUE_STRING: if (_stringDeserializer != null) { return _stringDeserializer.deserialize(jp, ctxt); } return jp.getText(); case VALUE_NUMBER_INT: if (_numberDeserializer != null) { return _numberDeserializer.deserialize(jp, ctxt); } // For [JACKSON-100], see above: if (ctxt.isEnabled(DeserializationFeature.USE_BIG_INTEGER_FOR_INTS)) { return jp.getBigIntegerValue(); } /* and as per [JACKSON-839], allow "upgrade" to bigger types: out-of-range * entries can not be produced without type, so this should "just work", * even if it is bit unclean */ return jp.getNumberValue(); case VALUE_NUMBER

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>_FLOAT: if (_numberDeserializer != null) { return _numberDeserializer.deserialize(jp, ctxt); } // For [JACKSON-72], see above if (ctxt.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)) { return jp.getDecimalValue(); } return Double.valueOf(jp.getDoubleValue()); case VALUE_TRUE: return Boolean.TRUE; case VALUE_FALSE: return Boolean.FALSE; case VALUE_EMBEDDED_OBJECT: return jp.getEmbeddedObject(); case VALUE_NULL: // should not get this far really but... return null; default: throw ctxt.mappingException(Object.class); } } /* /********************************************************** /* Internal methods /********************************************************** */ /** * Method called to map a JSON Array into a Java value. */ protected Object mapArray(JsonParser jp, DeserializationContext ctxt) throws IOException { // Minor optimization to handle small lists (default size for ArrayList is 10) if (jp.nextToken() == JsonToken.END_ARRAY) { return new ArrayList<Object>(2); } Object value = deserialize(jp, ctxt); if (jp.nextToken() == JsonToken.END_ARRAY) { ArrayList<Object> l = new ArrayList<Object>(2); l.add(value); return l; } Object value2 = deserialize(jp, ctxt); if (jp.nextToken() == JsonToken.END_ARRAY) { ArrayList<Object> l = new ArrayList<Object>(2); l.add(value); l.add(value2); return l; } ObjectBuffer buffer = ctxt.leaseObjectBuffer(); Object[] values = buffer.resetAndStart(); int ptr = 0; values[ptr++] = value; values[ptr++] = value2; int totalSize = ptr; do { value = deserialize(jp, ctxt); ++totalSize; if (ptr >= values.length) { values = buffer.appendCompletedChunk(values); ptr = 0; } values[ptr++] = value; } while (jp.nextToken() != JsonToken.END_ARRAY); // let's create full array then

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>0) if (jp.nextToken() == JsonToken.END_ARRAY) { return NO_OBJECTS; } ObjectBuffer buffer = ctxt.leaseObjectBuffer(); Object[] values = buffer.resetAndStart(); int ptr = 0; do { Object value = deserialize(jp, ctxt); if (ptr >= values.length) { values = buffer.appendCompletedChunk(values); ptr = 0; } values[ptr++] = value; } while (jp.nextToken() != JsonToken.END_ARRAY); return buffer.completeAndClearBuffer(values, ptr); } /* /********************************************************** /* Separate "vanilla" implementation for common case of /* no custom deserializer overrides /********************************************************** */ @JacksonStdImpl public static class Vanilla extends StdDeserializer<Object> { private static final long serialVersionUID = 1L; public final static Vanilla std = new Vanilla(); public Vanilla() { super(Object.class); } @Override public Object deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException { switch (jp.getCurrentTokenId()) { case JsonTokenId.ID_START_OBJECT: { JsonToken t = jp.nextToken(); if (t == JsonToken.END_OBJECT) { return new LinkedHashMap<String,Object>(2); } } case JsonTokenId.ID_FIELD_NAME: return mapObject(jp, ctxt); case JsonTokenId.ID_START_ARRAY: { JsonToken t = jp.nextToken(); if (t == JsonToken.END_ARRAY) { // and empty one too if (ctxt.isEnabled(DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY)) { return NO_OBJECTS; } return new ArrayList<Object>(2); } } if (ctxt.isEnabled(DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY)) { return mapArrayToArray(jp, ctxt); } return mapArray(jp, ctxt); case JsonTokenId.ID_EMBEDDED_OBJECT: return jp.getEmbeddedObject(); case JsonTokenId.ID_STRING: return jp.getText(); case JsonTokenId.ID_NUMBER_INT:

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> if (ctxt.isEnabled(DeserializationFeature.USE_BIG_INTEGER_FOR_INTS)) { return jp.getBigIntegerValue(); // should be optimal, whatever it is } return jp.getNumberValue(); // should be optimal, whatever it is case JsonTokenId.ID_NUMBER_FLOAT: if (ctxt.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)) { return jp.getDecimalValue(); } return Double.valueOf(jp.getDoubleValue()); case JsonTokenId.ID_TRUE: return Boolean.TRUE; case JsonTokenId.ID_FALSE: return Boolean.FALSE; case JsonTokenId.ID_NULL: // should not get this but... return null; //case JsonTokenId.ID_END_ARRAY: // invalid //case JsonTokenId.ID_END_OBJECT: // invalid default: throw ctxt.mappingException(Object.class); } } @Override public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException { switch (jp.getCurrentTokenId()) { case JsonTokenId.ID_START_ARRAY: case JsonTokenId.ID_START_OBJECT: case JsonTokenId.ID_FIELD_NAME: return typeDeserializer.deserializeTypedFromAny(jp, ctxt); case JsonTokenId.ID_STRING: return jp.getText(); case JsonTokenId.ID_NUMBER_INT: if (ctxt.isEnabled(DeserializationFeature.USE_BIG_INTEGER_FOR_INTS)) { return jp.getBigIntegerValue(); } return jp.getNumberValue(); case JsonTokenId.ID_NUMBER_FLOAT: if (ctxt.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)) { return jp.getDecimalValue(); } return Double.valueOf(jp.getDoubleValue()); case JsonTokenId.ID_TRUE: return Boolean.TRUE; case JsonTokenId.ID_FALSE: return Boolean.FALSE; case JsonTokenId.ID_EMBEDDED_OBJECT: return jp.getEmbeddedObject(); case JsonTokenId.ID_NULL: // should not get this far really but... return null; default: throw ctxt.mappingException(Object.

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>class); } } protected Object mapArray(JsonParser jp, DeserializationContext ctxt) throws IOException { Object value = deserialize(jp, ctxt); if (jp.nextToken() == JsonToken.END_ARRAY) { ArrayList<Object> l = new ArrayList<Object>(2); l.add(value); return l; } Object value2 = deserialize(jp, ctxt); if (jp.nextToken() == JsonToken.END_ARRAY) { ArrayList<Object> l = new ArrayList<Object>(2); l.add(value); l.add(value2); return l; } ObjectBuffer buffer = ctxt.leaseObjectBuffer(); Object[] values = buffer.resetAndStart(); int ptr = 0; values[ptr++] = value; values[ptr++] = value2; int totalSize = ptr; do { value = deserialize(jp, ctxt); ++totalSize; if (ptr >= values.length) { values = buffer.appendCompletedChunk(values); ptr = 0; } values[ptr++] = value; } while (jp.nextToken() != JsonToken.END_ARRAY); // let's create full array then ArrayList<Object> result = new ArrayList<Object>(totalSize); buffer.completeAndClearBuffer(values, ptr, result); return result; } /** * Method called to map a JSON Object into a Java value. */ protected Object mapObject(JsonParser jp, DeserializationContext ctxt) throws IOException { // will point to FIELD_NAME at this point, guaranteed String field1 = jp.getText(); jp.nextToken(); Object value1 = deserialize(jp, ctxt); if (jp.nextToken() == JsonToken.END_OBJECT) { // single entry; but we want modifiable LinkedHashMap<String, Object> result = new LinkedHashMap<String, Object>(2); result.put(field1, value1); return result; } String field2 = jp.getText(); jp.nextToken(); Object value2 = deserialize(jp, ctxt); if (jp.nextToken() == JsonToken.END_OBJECT) { LinkedHashMap<String, Object> result = new LinkedHashMap<String, Object>(4); result.put(field1

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser.impl; import com.fasterxml.jackson.annotation.ObjectIdGenerator; import com.fasterxml.jackson.annotation.ObjectIdGenerators; // Simple placeholder public class PropertyBasedObjectIdGenerator extends ObjectIdGenerators.PropertyGenerator { private static final long serialVersionUID = 1L; public PropertyBasedObjectIdGenerator(Class<?> scope) { super(scope); } @Override public Object generateId(Object forPojo) { throw new UnsupportedOperationException(); } @Override public ObjectIdGenerator<Object> forScope(Class<?> scope) { return (scope == _scope) ? this : new PropertyBasedObjectIdGenerator(scope); } @Override public ObjectIdGenerator<Object> newForSerialization(Object context) { return this; } @Override public com.fasterxml.jackson.annotation.ObjectIdGenerator.IdKey key(Object key) { if (key == null) { return null; } // should we use general type for all; or type of property itself? return new IdKey(getClass(), _scope, key); } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.impl; import com.fasterxml.jackson.annotation.ObjectIdGenerator; import com.fasterxml.jackson.annotation.ObjectIdGenerators; import com.fasterxml.jackson.databind.introspect.ObjectIdInfo; import com.fasterxml.jackson.databind.ser.*; public class PropertyBasedObjectIdGenerator extends ObjectIdGenerators.PropertyGenerator { private static final long serialVersionUID = 1L; protected final BeanPropertyWriter _property; public PropertyBasedObjectIdGenerator(ObjectIdInfo oid, BeanPropertyWriter prop) { this(oid.getScope(), prop); } protected PropertyBasedObjectIdGenerator(Class<?> scope, BeanPropertyWriter prop) { super(scope); _property = prop; } /** * We must override this method, to prevent errors when scopes are the same, * but underlying class (on which to access property) is different. */ @Override public boolean canUseFor(ObjectIdGenerator<?> gen) { if (gen.getClass() == getClass()) { PropertyBasedObjectIdGenerator other = (PropertyBasedObjectIdGenerator) gen; if (other.getScope() == _scope) { /* 26-Jul-2012, tatu: This is actually not enough, because the property * accessor within BeanPropertyWriter won't work for other property fields * (see [https://github.com/FasterXML/jackson-module-jaxb-annotations/issues/9] * for details). * So we need to verify that underlying property is actually the same. */ return (other._property == _property); } } return false; } @Override public Object generateId(Object forPojo) { try { return _property.get(forPojo); } catch (RuntimeException e) { throw e; } catch (Exception e) { throw new IllegalStateException("Problem accessing property '" +_property.getName()+"': "+e.getMessage(), e); } } @Override public ObjectIdGenerator<Object> forScope(Class<?> scope) { return (scope == _scope) ? this : new PropertyBasedObjectIdGenerator(scope, _property); } @Override public ObjectIdGenerator<Object> newForSerialization(Object context) { // No state

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>, can return this return this; } @Override public com.fasterxml.jackson.annotation.ObjectIdGenerator.IdKey key(Object key) { if (key == null) { return null; } // should we use general type for all; or type of property itself? return new IdKey(getClass(), _scope, key); } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.impl; import java.io.IOException; import java.lang.reflect.Type; import com.fasterxml.jackson.core.JsonGenerationException; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.annotation.JacksonStdImpl; import com.fasterxml.jackson.databind.introspect.AnnotatedMember; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonArrayFormatVisitor; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatTypes; import com.fasterxml.jackson.databind.jsontype.TypeSerializer; import com.fasterxml.jackson.databind.ser.ContainerSerializer; import com.fasterxml.jackson.databind.ser.ContextualSerializer; import com.fasterxml.jackson.databind.ser.std.ArraySerializerBase; import com.fasterxml.jackson.databind.type.TypeFactory; /** * Standard serializer used for <code>String[]</code> values. */ @JacksonStdImpl @SuppressWarnings("serial") public class StringArraySerializer extends ArraySerializerBase<String[]> implements ContextualSerializer { /* Note: not clean in general, but we are betting against * anyone re-defining properties of String.class here... */ private final static JavaType VALUE_TYPE = TypeFactory.defaultInstance().uncheckedSimpleType(String.class); public final static StringArraySerializer instance = new StringArraySerializer(); /** * Value serializer to use, if it's not the standard one * (if it is we can optimize serialization a lot) */ protected final JsonSerializer<Object> _elementSerializer; /* /********************************************************** /* Life-cycle /********************************************************** */ protected StringArraySerializer() { super(String[].class, null); _elementSerializer = null; } @SuppressWarnings("unchecked") public StringArraySerializer(StringArraySerializer src, BeanProperty prop, JsonSerializer<?> ser) { super(src, prop); _elementSerializer = (JsonSerializer<Object>) ser; } /** * Strings never add type info; hence, even if

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> type serializer is suggested, * we'll ignore it... */ @Override public ContainerSerializer<?> _withValueTypeSerializer(TypeSerializer vts) { return this; } /* /********************************************************** /* Post-processing /********************************************************** */ @Override public JsonSerializer<?> createContextual(SerializerProvider provider, BeanProperty property) throws JsonMappingException { /* 29-Sep-2012, tatu: Actually, we need to do much more contextual * checking here since we finally know for sure the property, * and it may have overrides */ JsonSerializer<?> ser = null; // First: if we have a property, may have property-annotation overrides if (property != null) { AnnotatedMember m = property.getMember(); if (m != null) { Object serDef = provider.getAnnotationIntrospector().findContentSerializer(m); if (serDef != null) { ser = provider.serializerInstance(m, serDef); } } } if (ser == null) { ser = _elementSerializer; } // #124: May have a content converter ser = findConvertingContentSerializer(provider, property, ser); if (ser == null) { ser = provider.findValueSerializer(String.class, property); } else { ser = provider.handleSecondaryContextualization(ser, property); } // Optimization: default serializer just writes String, so we can avoid a call: if (isDefaultSerializer(ser)) { ser = null; } // note: will never have TypeSerializer, because Strings are "natural" type if (ser == _elementSerializer) { return this; } return new StringArraySerializer(this, property, ser); } /* /********************************************************** /* Simple accessors /********************************************************** */ @Override public JavaType getContentType() { return VALUE_TYPE; } @Override public JsonSerializer<?> getContentSerializer() { return _elementSerializer; } @Override public boolean isEmpty(SerializerProvider prov, String[] value) { return (value == null) || (value.length == 0); } @Override public boolean hasSingleElement(String[] value) { return (value.length

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>y recursive generic * type, to allow for sub-classing of build methods with property type * co-variance. *<p> * Note on <code>JsonAutoDetect</code> annotation: it is used to * access default minimum visibility access definitions. */ @JsonAutoDetect( getterVisibility = Visibility.PUBLIC_ONLY, isGetterVisibility = Visibility.PUBLIC_ONLY, setterVisibility = Visibility.ANY, /** * By default, all matching single-arg constructed are found, * regardless of visibility. Does not apply to factory methods, * they can not be auto-detected; ditto for multiple-argument * constructors. */ creatorVisibility = Visibility.ANY, fieldVisibility = Visibility.PUBLIC_ONLY ) public static class Std implements VisibilityChecker<Std>, java.io.Serializable { private static final long serialVersionUID = 1; /** * This is the canonical base instance, configured with default * visibility values */ protected final static Std DEFAULT = new Std(Std.class.getAnnotation(JsonAutoDetect.class)); protected final Visibility _getterMinLevel; protected final Visibility _isGetterMinLevel; protected final Visibility _setterMinLevel; protected final Visibility _creatorMinLevel; protected final Visibility _fieldMinLevel; public static Std defaultInstance() { return DEFAULT; } /** * Constructor used for building instance that has minumum visibility * levels as indicated by given annotation instance * * @param ann Annotations to use for determining minimum visibility levels */ public Std(JsonAutoDetect ann) { // let's combine checks for enabled/disabled, with minimimum level checks: _getterMinLevel = ann.getterVisibility(); _isGetterMinLevel = ann.isGetterVisibility(); _setterMinLevel = ann.setterVisibility(); _creatorMinLevel = ann.creatorVisibility(); _fieldMinLevel = ann.fieldVisibility(); } /** * Constructor that allows directly specifying minimum visibility levels to use */ public Std(Visibility getter, Visibility isGetter, Visibility setter, Visibility creator, Visibility field) { _getterMinLevel = getter; _isGetterMinLevel = isGetter; _setterMinLevel = setter; _creatorMinLevel = creator; _fieldMinLevel = field; } /**

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> return true; } @Override public void serializeAsField(Object bean, JsonGenerator jgen, SerializerProvider prov) throws Exception { final Object value = get(bean); if (value == null) { // Hmmh. I assume we MUST pretty much suppress nulls, since we // can't really unwrap them... return; } JsonSerializer<Object> ser = _serializer; if (ser == null) { Class<?> cls = value.getClass(); PropertySerializerMap map = _dynamicSerializers; ser = map.serializerFor(cls); if (ser == null) { ser = _findAndAddDynamic(map, cls, prov); } } if (_suppressableValue != null) { if (MARKER_FOR_EMPTY == _suppressableValue) { if (ser.isEmpty(prov, value)) { return; } } else if (_suppressableValue.equals(value)) { return; } } // For non-nulls, first: simple check for direct cycles if (value == bean) { if (_handleSelfReference(bean, jgen, prov, ser)) { return; } } // note: must verify we are using unwrapping serializer; if not, will write field name if (!ser.isUnwrappingSerializer()) { jgen.writeFieldName(_name); } if (_typeSerializer == null) { ser.serialize(value, jgen, prov); } else { ser.serializeWithType(value, jgen, prov, _typeSerializer); } } // need to override as we must get unwrapping instance... @Override public void assignSerializer(JsonSerializer<Object> ser) { super.assignSerializer(ser); if (_serializer != null) { NameTransformer t = _nameTransformer; if (_serializer.isUnwrappingSerializer()) { t = NameTransformer.chainedTransformer(t, ((UnwrappingBeanSerializer) _serializer)._nameTransformer); } _serializer = _serializer.unwrappingSerializer(t); } } /* /********************************************************** /* Overrides: schema generation /********************************************************** */ @Override public void depositSchemaProperty(final JsonObjectFormatVisitor visitor) throws JsonMappingException { SerializerProvider provider = visitor.

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> given type. * Note: "natural types" (String, Boolean, Integer, Double) will never * use typing; that is both due to them being concrete and final, * and since actual serializers and deserializers will also ignore any * attempts to enforce typing. */ public boolean useForType(JavaType t) { switch (_appliesFor) { case NON_CONCRETE_AND_ARRAYS: while (t.isArrayType()) { t = t.getContentType(); } // fall through case OBJECT_AND_NON_CONCRETE: return (t.getRawClass() == Object.class) || !t.isConcrete() // [Issue#88] Should not apply to JSON tree models: || TreeNode.class.isAssignableFrom(t.getRawClass()); case NON_FINAL: while (t.isArrayType()) { t = t.getContentType(); } // [Issue#88] Should not apply to JSON tree models: return !t.isFinal() && !TreeNode.class.isAssignableFrom(t.getRawClass()); default: //case JAVA_LANG_OBJECT: return (t.getRawClass() == Object.class); } } } /* /********************************************************** /* Internal constants, singletons /********************************************************** */ // Quick little shortcut, to avoid having to use global TypeFactory instance... private final static JavaType JSON_NODE_TYPE = SimpleType.constructUnsafe(JsonNode.class); // 16-May-2009, tatu: Ditto ^^^ protected final static AnnotationIntrospector DEFAULT_ANNOTATION_INTROSPECTOR = new JacksonAnnotationIntrospector(); protected final static VisibilityChecker<?> STD_VISIBILITY_CHECKER = VisibilityChecker.Std.defaultInstance(); protected final static PrettyPrinter _defaultPrettyPrinter = new DefaultPrettyPrinter(); /** * Base settings contain defaults used for all {@link ObjectMapper} * instances. */ protected final static BaseSettings DEFAULT_BASE = new BaseSettings( null, // can not share global ClassIntrospector any more (2.5+) DEFAULT_ANNOTATION_INTROSPECTOR, STD_VISIBILITY_CHECKER, null, TypeFactory.defaultInstance(), null, StdDateFormat.instance, null, Locale.getDefault

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> Overridable helper method used to construct default {@link ClassIntrospector} * to use. * * @since 2.5 */ protected ClassIntrospector defaultClassIntrospector() { return new BasicClassIntrospector(); } /* /********************************************************** /* Methods sub-classes MUST override /********************************************************** */ /** * Method for creating a new {@link ObjectMapper} instance that * has same initial configuration as this instance. Note that this * also requires making a copy of the underlying {@link JsonFactory} * instance. *<p> * Method is typically * used when multiple, differently configured mappers are needed. * Although configuration is shared, cached serializers and deserializers * are NOT shared, which means that the new instance may be re-configured * before use; meaning that it behaves the same way as if an instance * was constructed from scratch. * * @since 2.1 */ public ObjectMapper copy() { _checkInvalidCopy(ObjectMapper.class); return new ObjectMapper(this); } /** * @since 2.1 */ protected void _checkInvalidCopy(Class<?> exp) { if (getClass() != exp) { throw new IllegalStateException("Failed copy(): "+getClass().getName() +" (version: "+version()+") does not override copy(); it has to"); } } /* /********************************************************** /* Methods sub-classes MUST override if providing custom /* ObjectReader/ObjectWriter implementations /********************************************************** */ /** * Factory method sub-classes must override, to produce {@link ObjectReader} * instances of proper sub-type * * @since 2.5 */ protected ObjectReader _newReader(DeserializationConfig config) { return new ObjectReader(this, config); } /** * Factory method sub-classes must override, to produce {@link ObjectReader} * instances of proper sub-type * * @since 2.5 */ protected ObjectReader _newReader(DeserializationConfig config, JavaType valueType, Object valueToUpdate, FormatSchema schema, InjectableValues injectableValues) { return new ObjectReader(this, config, valueType, valueToUpdate, schema, injectableValues); } /** * Factory method sub-classes must override

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>, Class<?> mixinSource) { mapper.addMixIn(target, mixinSource); } @Override public void addDeserializationProblemHandler(DeserializationProblemHandler handler) { mapper.addHandler(handler); } @Override public void setNamingStrategy(PropertyNamingStrategy naming) { mapper.setPropertyNamingStrategy(naming); } }); return this; } /** * Convenience method for registering specified modules in order; * functionally equivalent to: *<pre> * for (Module module : modules) { * registerModule(module); * } *</pre> * * @since 2.2 */ public ObjectMapper registerModules(Module... modules) { for (Module module : modules) { registerModule(module); } return this; } /** * Convenience method for registering specified modules in order; * functionally equivalent to: *<pre> * for (Module module : modules) { * registerModule(module); * } *</pre> * * @since 2.2 */ public ObjectMapper registerModules(Iterable<Module> modules) { for (Module module : modules) { registerModule(module); } return this; } /** * Method for locating available methods, using JDK {@link ServiceLoader} * facility, along with module-provided SPI. *<p> * Note that method does not do any caching, so calls should be considered * potentially expensive. * * @since 2.2 */ public static List<Module> findModules() { return findModules(null); } /** * Method for locating available methods, using JDK {@link ServiceLoader} * facility, along with module-provided SPI. *<p> * Note that method does not do any caching, so calls should be considered * potentially expensive. * * @since 2.2 */ public static List<Module> findModules(ClassLoader classLoader) { ArrayList<Module> modules = new ArrayList<Module>(); ServiceLoader<Module> loader = (classLoader == null) ? ServiceLoader.load(Module.class) : ServiceLoader.load(Module.class, classLoader); for (Module module :

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> out of JSON tree * representation. * * @param n Root node of the tree that resulting parser will read from */ @Override public JsonParser treeAsTokens(TreeNode n) { return new TreeTraversingParser((JsonNode) n, this); } /** * Convenience conversion method that will bind data given JSON tree * contains into specific value (usually bean) type. *<p> * Functionally equivalent to: *<pre> * objectMapper.convertValue(n, valueClass); *</pre> */ @SuppressWarnings("unchecked") @Override public <T> T treeToValue(TreeNode n, Class<T> valueType) throws JsonProcessingException { try { // [Issue-11]: Simple cast when we just want to cast to, say, ObjectNode // ... one caveat; while everything is Object.class, let's not take shortcut if (valueType != Object.class && valueType.isAssignableFrom(n.getClass())) { return (T) n; } return readValue(treeAsTokens(n), valueType); } catch (JsonProcessingException e) { throw e; } catch (IOException e) { // should not occur, no real i/o... throw new IllegalArgumentException(e.getMessage(), e); } } /** * Reverse of {@link #treeToValue}; given a value (usually bean), will * construct equivalent JSON Tree representation. Functionally similar * to serializing value into JSON and parsing JSON as tree, but * more efficient. *<p> * NOTE: one known difference from actual serialization is that so-called * "raw values" are not supported -- since they are opaque sequence of * bytes to include (which may or may not be supported by the backend) * they can not be converted using this method. It may be possible to * support conversions using full serialization, if raw values must be * preserved. * * @param <T> Actual node type; usually either basic {@link JsonNode} or * {@link com.fasterxml.jackson.databind.node.ObjectNode} * @param fromValue Bean value to convert * @return Root node of the resulting JSON tree */ @SuppressWarnings({ "unchecked", "resource" }) public <T extends JsonNode

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>; instead give updateable object is used * as root. * Runtime type of value object is used for locating deserializer, * unless overridden by other factory methods of {@link ObjectReader} */ @SuppressWarnings("unchecked") public <T extends ObjectReader> T readerForUpdating(Object valueToUpdate) { JavaType t = _typeFactory.constructType(valueToUpdate.getClass()); return (T) _newReader(getDeserializationConfig(), t, valueToUpdate, null, _injectableValues); } /** * Factory method for constructing {@link ObjectReader} that will * read or update instances of specified type */ @SuppressWarnings("unchecked") public <T extends ObjectReader> T reader(JavaType type) { return (T) _newReader(getDeserializationConfig(), type, null, null, _injectableValues); } /** * Factory method for constructing {@link ObjectReader} that will * read or update instances of specified type */ @SuppressWarnings("unchecked") public <T extends ObjectReader> T reader(Class<?> type) { return (T) _newReader(getDeserializationConfig(), _typeFactory.constructType(type), null, null, _injectableValues); } /** * Factory method for constructing {@link ObjectReader} that will * read or update instances of specified type */ @SuppressWarnings("unchecked") public <T extends ObjectReader> T reader(TypeReference<?> type) { return (T)_newReader(getDeserializationConfig(), _typeFactory.constructType(type), null, null, _injectableValues); } /** * Factory method for constructing {@link ObjectReader} that will * use specified {@link JsonNodeFactory} for constructing JSON trees. */ @SuppressWarnings("unchecked") public <T extends ObjectReader> T reader(JsonNodeFactory f) { return (T) _newReader(getDeserializationConfig()).with(f); } /** * Factory method for constructing {@link ObjectReader} that will * pass specific schema object to {@link JsonParser} used for * reading content. * * @param schema Schema to pass to parser */ @SuppressWarnings("unchecked") public <T extends ObjectReader> T reader(FormatSchema schema) { _verifySchemaType(schema); return (T)_newReader

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> convertValue(Object fromValue, Class<T> toValueType) throws IllegalArgumentException { // sanity check for null first: if (fromValue == null) return null; return (T) _convert(fromValue, _typeFactory.constructType(toValueType)); } @SuppressWarnings("unchecked") public <T> T convertValue(Object fromValue, TypeReference<?> toValueTypeRef) throws IllegalArgumentException { return (T) convertValue(fromValue, _typeFactory.constructType(toValueTypeRef)); } @SuppressWarnings("unchecked") public <T> T convertValue(Object fromValue, JavaType toValueType) throws IllegalArgumentException { // sanity check for null first: if (fromValue == null) return null; return (T) _convert(fromValue, toValueType); } /** * Actual conversion implementation: instead of using existing read * and write methods, much of code is inlined. Reason for this is * that we must avoid root value wrapping/unwrapping both for efficiency and * for correctness. If root value wrapping/unwrapping is actually desired, * caller must use explicit <code>writeValue</code> and * <code>readValue</code> methods. */ @SuppressWarnings("resource") protected Object _convert(Object fromValue, JavaType toValueType) throws IllegalArgumentException { // also, as per [Issue-11], consider case for simple cast /* But with caveats: one is that while everything is Object.class, we don't * want to "optimize" that out; and the other is that we also do not want * to lose conversions of generic types. */ Class<?> targetType = toValueType.getRawClass(); if (targetType != Object.class && !toValueType.hasGenericTypes() && targetType.isAssignableFrom(fromValue.getClass())) { return fromValue; } /* Then use TokenBuffer, which is a JsonGenerator: * (see [JACKSON-175]) */ TokenBuffer buf = new TokenBuffer(this, false); try { // inlined 'writeValue' with minor changes: // first: disable wrapping when writing SerializationConfig config = getSerializationConfig().without(SerializationFeature.WRAP_ROOT_VALUE); // no need to check for closing of TokenBuffer

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>expName+"'), but "+p.getCurrentToken()); } String actualName = p.getCurrentName(); if (!expName.equals(actualName)) { throw JsonMappingException.from(p, "Root name '"+actualName+"' does not match expected ('" +expName+"') for type "+rootType); } // ok, then move to value itself.... p.nextToken(); Object result = deser.deserialize(p, ctxt); // and last, verify that we now get matching END_OBJECT if (p.nextToken() != JsonToken.END_OBJECT) { throw JsonMappingException.from(p, "Current token not END_OBJECT (to match wrapper object with root name '" +expName+"'), but "+p.getCurrentToken()); } return result; } /* /********************************************************** /* Internal methods, other /********************************************************** */ /** * Method called to locate deserializer for the passed root-level value. */ protected JsonDeserializer<Object> _findRootDeserializer(DeserializationContext ctxt, JavaType valueType) throws JsonMappingException { // First: have we already seen it? JsonDeserializer<Object> deser = _rootDeserializers.get(valueType); if (deser != null) { return deser; } // Nope: need to ask provider to resolve it deser = ctxt.findRootValueDeserializer(valueType); if (deser == null) { // can this happen? throw new JsonMappingException("Can not find a deserializer for type "+valueType); } _rootDeserializers.put(valueType, deser); return deser; } /** * @since 2.2 */ protected void _verifySchemaType(FormatSchema schema) { if (schema != null) { if (!_jsonFactory.canUseSchema(schema)) { throw new IllegalArgumentException("Can not use FormatSchema of type "+schema.getClass().getName() +" for format "+_jsonFactory.getFormatName()); } } } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.introspect; import java.lang.annotation.Annotation; import java.util.*; import com.fasterxml.jackson.annotation.*; import com.fasterxml.jackson.core.Version; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.annotation.*; import com.fasterxml.jackson.databind.cfg.HandlerInstantiator; import com.fasterxml.jackson.databind.cfg.MapperConfig; import com.fasterxml.jackson.databind.jsontype.NamedType; import com.fasterxml.jackson.databind.jsontype.TypeIdResolver; import com.fasterxml.jackson.databind.jsontype.TypeResolverBuilder; import com.fasterxml.jackson.databind.jsontype.impl.StdTypeResolverBuilder; import com.fasterxml.jackson.databind.ser.BeanPropertyWriter; import com.fasterxml.jackson.databind.ser.VirtualBeanPropertyWriter; import com.fasterxml.jackson.databind.ser.impl.AttributePropertyWriter; import com.fasterxml.jackson.databind.ser.std.RawSerializer; import com.fasterxml.jackson.databind.util.*; /** * {@link AnnotationIntrospector} implementation that handles standard * Jackson annotations. */ public class JacksonAnnotationIntrospector extends AnnotationIntrospector implements java.io.Serializable { private static final long serialVersionUID = 1L; public JacksonAnnotationIntrospector() { } @Override public Version version() { return com.fasterxml.jackson.databind.cfg.PackageVersion.VERSION; } /* /********************************************************** /* General annotation properties /********************************************************** */ /** * Annotations with meta-annotation {@link JacksonAnnotationsInside} * are considered bundles. */ @Override public boolean isAnnotationBundle(Annotation ann) { return ann.annotationType().getAnnotation(JacksonAnnotationsInside.class) != null; } /* /********************************************************** /* General annotations /********************************************************** */ // default impl is fine: //public String findEnumValue(Enum<?> value) { return value.name(); } /* /********************************************************** /* General class annotations /********************************************************** */ @Override public PropertyName findRootName(AnnotatedClass ac) { JsonRootName

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> ann = _findAnnotation(ac, JsonRootName.class); if (ann == null) { return null; } String ns = ann.namespace(); if (ns != null && ns.length() == 0) { ns = null; } return PropertyName.construct(ann.value(), ns); } @Override public String[] findPropertiesToIgnore(Annotated ac) { JsonIgnoreProperties ignore = _findAnnotation(ac, JsonIgnoreProperties.class); return (ignore == null) ? null : ignore.value(); } @Override public Boolean findIgnoreUnknownProperties(AnnotatedClass ac) { JsonIgnoreProperties ignore = _findAnnotation(ac, JsonIgnoreProperties.class); return (ignore == null) ? null : ignore.ignoreUnknown(); } @Override public Boolean isIgnorableType(AnnotatedClass ac) { JsonIgnoreType ignore = _findAnnotation(ac, JsonIgnoreType.class); return (ignore == null) ? null : ignore.value(); } /** * @deprecated (since 2.3) Use {@link #findFilterId(Annotated)} instead */ @Deprecated @Override public Object findFilterId(AnnotatedClass ac) { return _findFilterId(ac); } @Override public Object findFilterId(Annotated a) { return _findFilterId(a); } protected final Object _findFilterId(Annotated a) { JsonFilter ann = _findAnnotation(a, JsonFilter.class); if (ann != null) { String id = ann.value(); // Empty String is same as not having annotation, to allow overrides if (id.length() > 0) { return id; } } return null; } @Override public Object findNamingStrategy(AnnotatedClass ac) { JsonNaming ann = _findAnnotation(ac, JsonNaming.class); return (ann == null) ? null : ann.value(); } /* /********************************************************** /* Property auto-detection /********************************************************** */ @Override public VisibilityChecker<?> findAutoDetectVisibility(AnnotatedClass ac, VisibilityChecker<?> checker) { JsonAutoDetect ann = _findAnnotation(ac, JsonAutoDetect.class); return (ann == null) ? checker

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> : checker.with(ann); } /* /********************************************************** /* General member (field, method/constructor) annotations /********************************************************** */ @Override public ReferenceProperty findReferenceType(AnnotatedMember member) { JsonManagedReference ref1 = _findAnnotation(member, JsonManagedReference.class); if (ref1 != null) { return AnnotationIntrospector.ReferenceProperty.managed(ref1.value()); } JsonBackReference ref2 = _findAnnotation(member, JsonBackReference.class); if (ref2 != null) { return AnnotationIntrospector.ReferenceProperty.back(ref2.value()); } return null; } @Override public NameTransformer findUnwrappingNameTransformer(AnnotatedMember member) { JsonUnwrapped ann = _findAnnotation(member, JsonUnwrapped.class); // if not enabled, just means annotation is not enabled; not necessarily // that unwrapping should not be done (relevant when using chained introspectors) if (ann == null || !ann.enabled()) { return null; } String prefix = ann.prefix(); String suffix = ann.suffix(); return NameTransformer.simpleTransformer(prefix, suffix); } @Override public boolean hasIgnoreMarker(AnnotatedMember m) { return _isIgnorable(m); } @Override public Boolean hasRequiredMarker(AnnotatedMember m) { JsonProperty ann = _findAnnotation(m, JsonProperty.class); if (ann != null) { return ann.required(); } return null; } @Override public Object findInjectableValueId(AnnotatedMember m) { JacksonInject ann = _findAnnotation(m, JacksonInject.class); if (ann == null) { return null; } /* Empty String means that we should use name of declared * value class. */ String id = ann.value(); if (id.length() == 0) { // slight complication; for setters, type if (!(m instanceof AnnotatedMethod)) { return m.getRawType().getName(); } AnnotatedMethod am = (AnnotatedMethod) m; if (am.getParameterCount() == 0) { return m.getRawType().getName(); } return am.

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>getRawParameterType(0).getName(); } return id; } /* /********************************************************** /* Class annotations for PM type handling (1.5+) /********************************************************** */ @Override public TypeResolverBuilder<?> findTypeResolver(MapperConfig<?> config, AnnotatedClass ac, JavaType baseType) { return _findTypeResolver(config, ac, baseType); } @Override public TypeResolverBuilder<?> findPropertyTypeResolver(MapperConfig<?> config, AnnotatedMember am, JavaType baseType) { /* As per definition of @JsonTypeInfo, should only apply to contents of container * (collection, map) types, not container types themselves: */ if (baseType.isContainerType()) return null; // No per-member type overrides (yet) return _findTypeResolver(config, am, baseType); } @Override public TypeResolverBuilder<?> findPropertyContentTypeResolver(MapperConfig<?> config, AnnotatedMember am, JavaType containerType) { /* First: let's ensure property is a container type: caller should have * verified but just to be sure */ if (!containerType.isContainerType()) { throw new IllegalArgumentException("Must call method with a container type (got "+containerType+")"); } return _findTypeResolver(config, am, containerType); } @Override public List<NamedType> findSubtypes(Annotated a) { JsonSubTypes t = _findAnnotation(a, JsonSubTypes.class); if (t == null) return null; JsonSubTypes.Type[] types = t.value(); ArrayList<NamedType> result = new ArrayList<NamedType>(types.length); for (JsonSubTypes.Type type : types) { result.add(new NamedType(type.value(), type.name())); } return result; } @Override public String findTypeName(AnnotatedClass ac) { JsonTypeName tn = _findAnnotation(ac, JsonTypeName.class); return (tn == null) ? null : tn.value(); } /* /********************************************************** /* Serialization: general annotations /********************************************************** */ @Override public Object findSerializer(Annotated a) { JsonSerialize ann = _findAnnotation(a, JsonSerialize.class);

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> if (ann != null) { Class<? extends JsonSerializer<?>> serClass = ann.using(); if (serClass != JsonSerializer.None.class) { return serClass; } } /* 18-Oct-2010, tatu: [JACKSON-351] @JsonRawValue handled just here, for now; * if we need to get raw indicator from other sources need to add * separate accessor within {@link AnnotationIntrospector} interface. */ JsonRawValue annRaw = _findAnnotation(a, JsonRawValue.class); if ((annRaw != null) && annRaw.value()) { // let's construct instance with nominal type: Class<?> cls = a.getRawType(); return new RawSerializer<Object>(cls); } return null; } @Override public Class<? extends JsonSerializer<?>> findKeySerializer(Annotated a) { JsonSerialize ann = _findAnnotation(a, JsonSerialize.class); if (ann != null) { Class<? extends JsonSerializer<?>> serClass = ann.keyUsing(); if (serClass != JsonSerializer.None.class) { return serClass; } } return null; } @Override public Class<? extends JsonSerializer<?>> findContentSerializer(Annotated a) { JsonSerialize ann = _findAnnotation(a, JsonSerialize.class); if (ann != null) { Class<? extends JsonSerializer<?>> serClass = ann.contentUsing(); if (serClass != JsonSerializer.None.class) { return serClass; } } return null; } @Override public Object findNullSerializer(Annotated a) { JsonSerialize ann = _findAnnotation(a, JsonSerialize.class); if (ann != null) { Class<? extends JsonSerializer<?>> serClass = ann.nullsUsing(); if (serClass != JsonSerializer.None.class) { return serClass; } } return null; } @Override public JsonInclude.Include findSerializationInclusion(Annotated a, JsonInclude.Include defValue) { JsonInclude inc = _findAnnotation(a, JsonInclude.class); if (inc != null) { return inc.value(); } JsonSerialize ann = _findAnnotation(a, JsonSerialize.class

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>); if (ann != null) { @SuppressWarnings("deprecation") JsonSerialize.Inclusion i2 = ann.include(); switch (i2) { case ALWAYS: return JsonInclude.Include.ALWAYS; case NON_NULL: return JsonInclude.Include.NON_NULL; case NON_DEFAULT: return JsonInclude.Include.NON_DEFAULT; case NON_EMPTY: return JsonInclude.Include.NON_EMPTY; case DEFAULT_INCLUSION: // since 2.3 -- fall through, use default break; } } return defValue; } @Override public JsonInclude.Include findSerializationInclusionForContent(Annotated a, JsonInclude.Include defValue) { JsonInclude inc = _findAnnotation(a, JsonInclude.class); return (inc == null) ? defValue : inc.content(); } @Override public Class<?> findSerializationType(Annotated am) { JsonSerialize ann = _findAnnotation(am, JsonSerialize.class); return (ann == null) ? null : _classIfExplicit(ann.as()); } @Override public Class<?> findSerializationKeyType(Annotated am, JavaType baseType) { JsonSerialize ann = _findAnnotation(am, JsonSerialize.class); return (ann == null) ? null : _classIfExplicit(ann.keyAs()); } @Override public Class<?> findSerializationContentType(Annotated am, JavaType baseType) { JsonSerialize ann = _findAnnotation(am, JsonSerialize.class); return (ann == null) ? null : _classIfExplicit(ann.contentAs()); } @Override public JsonSerialize.Typing findSerializationTyping(Annotated a) { JsonSerialize ann = _findAnnotation(a, JsonSerialize.class); return (ann == null) ? null : ann.typing(); } @Override public Object findSerializationConverter(Annotated a) { JsonSerialize ann = _findAnnotation(a, JsonSerialize.class); return (ann == null) ? null : _classIfExplicit(ann.converter(), Converter.None.class); } @Override public Object findSerializationContentConverter(AnnotatedMember a) { JsonSerialize ann = _findAnnotation(a, JsonSerialize.class); return (ann

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> == null) ? null : _classIfExplicit(ann.contentConverter(), Converter.None.class); } @Override public Class<?>[] findViews(Annotated a) { JsonView ann = _findAnnotation(a, JsonView.class); return (ann == null) ? null : ann.value(); } @Override public Boolean isTypeId(AnnotatedMember member) { return _hasAnnotation(member, JsonTypeId.class); } @Override public ObjectIdInfo findObjectIdInfo(Annotated ann) { JsonIdentityInfo info = _findAnnotation(ann, JsonIdentityInfo.class); if (info == null || info.generator() == ObjectIdGenerators.None.class) { return null; } // In future may need to allow passing namespace? PropertyName name = new PropertyName(info.property()); return new ObjectIdInfo(name, info.scope(), info.generator(), info.resolver()); } @Override public ObjectIdInfo findObjectReferenceInfo(Annotated ann, ObjectIdInfo objectIdInfo) { JsonIdentityReference ref = _findAnnotation(ann, JsonIdentityReference.class); if (ref != null) { objectIdInfo = objectIdInfo.withAlwaysAsId(ref.alwaysAsId()); } return objectIdInfo; } @Override public JsonFormat.Value findFormat(Annotated ann) { JsonFormat f = _findAnnotation(ann, JsonFormat.class); return (f == null) ? null : new JsonFormat.Value(f); } @Override public String findPropertyDefaultValue(Annotated ann) { JsonProperty prop = _findAnnotation(ann, JsonProperty.class); if (prop == null) { return null; } String str = prop.defaultValue(); // Since annotations do not allow nulls, need to assume empty means "none" return str.isEmpty() ? null : str; } @Override public String findPropertyDescription(Annotated ann) { JsonPropertyDescription desc = _findAnnotation(ann, JsonPropertyDescription.class); return (desc == null) ? null : desc.value(); } @Override public Integer findPropertyIndex(Annotated ann) { JsonProperty prop = _findAnnotation(ann, JsonProperty.class); if (prop != null) { int

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> ix = prop.index(); if (ix != JsonProperty.INDEX_UNKNOWN) { return Integer.valueOf(ix); } } return null; } @Override public String findImplicitPropertyName(AnnotatedMember param) { // not known by default (until JDK8) for creators; default // return null; } /* /********************************************************** /* Serialization: class annotations /********************************************************** */ @Override public String[] findSerializationPropertyOrder(AnnotatedClass ac) { JsonPropertyOrder order = _findAnnotation(ac, JsonPropertyOrder.class); return (order == null) ? null : order.value(); } @Override public Boolean findSerializationSortAlphabetically(Annotated ann) { return _findSortAlpha(ann); } @Override @Deprecated public Boolean findSerializationSortAlphabetically(AnnotatedClass ac) { return _findSortAlpha(ac); } private final Boolean _findSortAlpha(Annotated ann) { JsonPropertyOrder order = _findAnnotation(ann, JsonPropertyOrder.class); return (order == null) ? null : order.alphabetic(); } @Override public void findAndAddVirtualProperties(MapperConfig<?> config, AnnotatedClass ac, List<BeanPropertyWriter> properties) { JsonAppend ann = _findAnnotation(ac, JsonAppend.class); if (ann == null) { return; } final boolean prepend = ann.prepend(); JavaType propType = null; // First: any attribute-backed properties? JsonAppend.Attr[] attrs = ann.attrs(); for (int i = 0, len = attrs.length; i < len; ++i) { if (propType == null) { propType = config.constructType(Object.class); } BeanPropertyWriter bpw = _constructVirtualProperty(attrs[i], config, ac, propType); if (prepend) { properties.add(i, bpw); } else { properties.add(bpw); } } // Then: general-purpose virtual properties? JsonAppend.Prop[] props = ann.props(); for (int i = 0, len = props.length; i < len; ++i) { BeanPropertyWriter bpw

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> hi.virtualPropertyWriterInstance(config, implClass); if (bpw == null) { bpw = (VirtualBeanPropertyWriter) ClassUtil.createInstance(implClass, config.canOverrideAccessModifiers()); } // one more thing: give it necessary contextual information return bpw.withConfig(config, ac, propDef, type); } /* /********************************************************** /* Serialization: property annotations /********************************************************** */ @Override public PropertyName findNameForSerialization(Annotated a) { String name = null; JsonGetter jg = _findAnnotation(a, JsonGetter.class); if (jg != null) { name = jg.value(); } else { JsonProperty pann = _findAnnotation(a, JsonProperty.class); if (pann != null) { name = pann.value(); } else if (_hasAnnotation(a, JsonSerialize.class) || _hasAnnotation(a, JsonView.class)) { name = ""; } else { return null; } } if (name.length() == 0) { // empty String means 'default' return PropertyName.USE_DEFAULT; } return new PropertyName(name); } @Override public boolean hasAsValueAnnotation(AnnotatedMethod am) { JsonValue ann = _findAnnotation(am, JsonValue.class); // value of 'false' means disabled... return (ann != null && ann.value()); } /* /********************************************************** /* Deserialization: general annotations /********************************************************** */ @Override public Class<? extends JsonDeserializer<?>> findDeserializer(Annotated a) { JsonDeserialize ann = _findAnnotation(a, JsonDeserialize.class); if (ann != null) { Class<? extends JsonDeserializer<?>> deserClass = ann.using(); if (deserClass != JsonDeserializer.None.class) { return deserClass; } } return null; } @Override public Class<? extends KeyDeserializer> findKeyDeserializer(Annotated a) { JsonDeserialize ann = _findAnnotation(a, JsonDeserialize.class); if (ann != null) { Class<? extends KeyDeserializer> deserClass = ann.keyUsing(); if (deserClass != KeyDeserializer.None.

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>class) { return deserClass; } } return null; } @Override public Class<? extends JsonDeserializer<?>> findContentDeserializer(Annotated a) { JsonDeserialize ann = _findAnnotation(a, JsonDeserialize.class); if (ann != null) { Class<? extends JsonDeserializer<?>> deserClass = ann.contentUsing(); if (deserClass != JsonDeserializer.None.class) { return deserClass; } } return null; } @Override public Class<?> findDeserializationType(Annotated am, JavaType baseType) { JsonDeserialize ann = _findAnnotation(am, JsonDeserialize.class); return (ann == null) ? null : _classIfExplicit(ann.as()); } @Override public Class<?> findDeserializationKeyType(Annotated am, JavaType baseKeyType) { JsonDeserialize ann = _findAnnotation(am, JsonDeserialize.class); return (ann == null) ? null : _classIfExplicit(ann.keyAs()); } @Override public Class<?> findDeserializationContentType(Annotated am, JavaType baseContentType) { JsonDeserialize ann = _findAnnotation(am, JsonDeserialize.class); return (ann == null) ? null : _classIfExplicit(ann.contentAs()); } @Override public Object findDeserializationConverter(Annotated a) { JsonDeserialize ann = _findAnnotation(a, JsonDeserialize.class); return (ann == null) ? null : _classIfExplicit(ann.converter(), Converter.None.class); } @Override public Object findDeserializationContentConverter(AnnotatedMember a) { JsonDeserialize ann = _findAnnotation(a, JsonDeserialize.class); return (ann == null) ? null : _classIfExplicit(ann.contentConverter(), Converter.None.class); } /* /********************************************************** /* Deserialization: Class annotations /********************************************************** */ @Override public Object findValueInstantiator(AnnotatedClass ac) { JsonValueInstantiator ann = _findAnnotation(ac, JsonValueInstantiator.class); // no 'null' marker yet, so: return (ann == null) ? null : ann.value(); } @Override public Class<?> findPOJOBuilder(AnnotatedClass ac) { JsonDeserialize ann = _findAnnotation

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>(ac, JsonDeserialize.class); return (ann == null) ? null : _classIfExplicit(ann.builder()); } @Override public JsonPOJOBuilder.Value findPOJOBuilderConfig(AnnotatedClass ac) { JsonPOJOBuilder ann = _findAnnotation(ac, JsonPOJOBuilder.class); return (ann == null) ? null : new JsonPOJOBuilder.Value(ann); } /* /********************************************************** /* Deserialization: property annotations /********************************************************** */ @Override public PropertyName findNameForDeserialization(Annotated a) { String name; // @JsonSetter has precedence over @JsonProperty, being more specific // @JsonDeserialize implies that there is a property, but no name JsonSetter js = _findAnnotation(a, JsonSetter.class); if (js != null) { name = js.value(); } else { JsonProperty pann = _findAnnotation(a, JsonProperty.class); if (pann != null) { name = pann.value(); /* 22-Apr-2014, tatu: Should figure out a better way to do this, but * it's actually bit tricky to do it more efficiently (meta-annotations * add more lookups; AnnotationMap costs etc) */ } else if (_hasAnnotation(a, JsonDeserialize.class) || _hasAnnotation(a, JsonView.class) || _hasAnnotation(a, JsonUnwrapped.class) // [#442] || _hasAnnotation(a, JsonBackReference.class) || _hasAnnotation(a, JsonManagedReference.class)) { name = ""; } else { return null; } } if (name.length() == 0) { // empty String means 'default' return PropertyName.USE_DEFAULT; } return new PropertyName(name); } @Override public boolean hasAnySetterAnnotation(AnnotatedMethod am) { /* No dedicated disabling; regular @JsonIgnore used * if needs to be ignored (and if so, is handled prior * to this method getting called) */ return _hasAnnotation(am, JsonAnySetter.class); } @Override public boolean hasAnyGetterAnnotation(AnnotatedMethod am) {

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> /* No dedicated disabling; regular @JsonIgnore used * if needs to be ignored (handled separately */ return _hasAnnotation(am, JsonAnyGetter.class); } @Override public boolean hasCreatorAnnotation(Annotated a) { /* No dedicated disabling; regular @JsonIgnore used * if needs to be ignored (and if so, is handled prior * to this method getting called) */ JsonCreator ann = _findAnnotation(a, JsonCreator.class); return (ann != null && ann.mode() != JsonCreator.Mode.DISABLED); } @Override public JsonCreator.Mode findCreatorBinding(Annotated a) { JsonCreator ann = _findAnnotation(a, JsonCreator.class); return (ann == null) ? null : ann.mode(); } /* /********************************************************** /* Helper methods /********************************************************** */ protected boolean _isIgnorable(Annotated a) { JsonIgnore ann = _findAnnotation(a, JsonIgnore.class); return (ann != null && ann.value()); } protected Class<?> _classIfExplicit(Class<?> cls) { if (cls == null || ClassUtil.isBogusClass(cls)) { return null; } return cls; } protected Class<?> _classIfExplicit(Class<?> cls, Class<?> implicit) { cls = _classIfExplicit(cls); return (cls == null || cls == implicit) ? null : cls; } protected PropertyName _propertyName(String localName, String namespace) { if (localName.isEmpty()) { return PropertyName.USE_DEFAULT; } if (namespace == null || namespace.isEmpty()) { return new PropertyName(localName); } return new PropertyName(localName, namespace); } /** * Helper method called to construct and initialize instance of {@link TypeResolverBuilder} * if given annotated element indicates one is needed. */ @SuppressWarnings("deprecation") protected TypeResolverBuilder<?> _findTypeResolver(MapperConfig<?> config, Annotated ann, JavaType baseType) { // First: maybe we have explicit type resolver? TypeResolverBuilder<?> b; JsonTypeInfo info = _findAnnotation(ann, JsonTypeInfo.class); JsonTypeResolver resAnn = _findAnnotation(ann, JsonType

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>Resolver.class); if (resAnn != null) { if (info == null) { return null; } /* let's not try to force access override (would need to pass * settings through if we did, since that's not doable on some * platforms) */ b = config.typeResolverBuilderInstance(ann, resAnn.value()); } else { // if not, use standard one, if indicated by annotations if (info == null) { return null; } // bit special; must return 'marker' to block use of default typing: if (info.use() == JsonTypeInfo.Id.NONE) { return _constructNoTypeResolverBuilder(); } b = _constructStdTypeResolverBuilder(); } // Does it define a custom type id resolver? JsonTypeIdResolver idResInfo = _findAnnotation(ann, JsonTypeIdResolver.class); TypeIdResolver idRes = (idResInfo == null) ? null : config.typeIdResolverInstance(ann, idResInfo.value()); if (idRes != null) { // [JACKSON-359] idRes.init(baseType); } b = b.init(info.use(), idRes); /* 13-Aug-2011, tatu: One complication wrt [JACKSON-453]; external id * only works for properties; so if declared for a Class, we will need * to map it to "PROPERTY" instead of "EXTERNAL_PROPERTY" */ JsonTypeInfo.As inclusion = info.include(); if (inclusion == JsonTypeInfo.As.EXTERNAL_PROPERTY && (ann instanceof AnnotatedClass)) { inclusion = JsonTypeInfo.As.PROPERTY; } b = b.inclusion(inclusion); b = b.typeProperty(info.property()); Class<?> defaultImpl = info.defaultImpl(); // 08-Dec-2014, tatu: To deprecated `JsonTypeInfo.None` we need to use other placeholder(s); // and since `java.util.Void` has other purpose (to indicate "deser as null"), we'll instead // use `JsonTypeInfo.class` itself. But any annotation type will actually do, as they have no

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> // valid use (can not instantiate as default) if (defaultImpl != JsonTypeInfo.None.class && !defaultImpl.isAnnotation()) { b = b.defaultImpl(defaultImpl); } b = b.typeIdVisibility(info.visible()); return b; } /** * Helper method for constructing standard {@link TypeResolverBuilder} * implementation. */ protected StdTypeResolverBuilder _constructStdTypeResolverBuilder() { return new StdTypeResolverBuilder(); } /** * Helper method for dealing with "no type info" marker; can't be null * (as it'd be replaced by default typing) */ protected StdTypeResolverBuilder _constructNoTypeResolverBuilder() { return StdTypeResolverBuilder.noTypeInfoBuilder(); } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind; import java.io.IOException; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.jsontype.TypeSerializer; /** * Interface that can be implemented by objects that know how to * serialize themselves to JSON, using {@link JsonGenerator} * (and {@link SerializerProvider} if necessary). *<p> * Note that implementing this interface binds implementing object * closely to Jackson API, and that it is often not necessary to do * so -- if class is a bean, it can be serialized without * implementing this interface. *<p> * NOTE: Jackson 2.0 added another method (from former "JsonSerializableWithType"), * which is required for proper handling of case where additional type information * is needed. */ public interface JsonSerializable { /** * Serialization method called when no additional type information is * to be included in serialization. */ public void serialize(JsonGenerator gen, SerializerProvider serializers) throws IOException; /** * Serialization method called when additional type information is * expected to be included in serialization, for deserialization to use. *<p> * Usually implementation consists of a call to one of methods * in {@link TypeSerializer} (such as {@link TypeSerializer#writeTypePrefixForObject(Object, JsonGenerator)}) * followed by serialization of contents, * followed by another call to {@link TypeSerializer} * (such as {@link TypeSerializer#writeTypeSuffixForObject(Object, JsonGenerator)}). * Exact methods to call in {@link TypeSerializer} depend on shape of JSON Object used * (Array, Object or scalar like String/Number/Boolean). *<p> * Note that some types (most notably, "natural" types: String, Integer, * Double and Boolean) never include type information. */ public void serializeWithType(JsonGenerator gen, SerializerProvider serializers, TypeSerializer typeSer) throws IOException; }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> } return; } // then find serializer to use JsonSerializer<Object> ser = _serializer; if (ser == null) { Class<?> cls = value.getClass(); PropertySerializerMap m = _dynamicSerializers; ser = m.serializerFor(cls); if (ser == null) { ser = _findAndAddDynamic(m, cls, prov); } } // and then see if we must suppress certain values (default, empty) if (_suppressableValue != null) { if (MARKER_FOR_EMPTY == _suppressableValue) { if (ser.isEmpty(prov, value)) { return; } } else if (_suppressableValue.equals(value)) { return; } } // For non-nulls: simple check for direct cycles if (value == bean) { // three choices: exception; handled by call; or pass-through if (_handleSelfReference(bean, gen, prov, ser)) { return; } } gen.writeFieldName(_name); if (_typeSerializer == null) { ser.serialize(value, gen, prov); } else { ser.serializeWithType(value, gen, prov, _typeSerializer); } } /** * Method called to indicate that serialization of a field was omitted * due to filtering, in cases where backend data format does not allow * basic omission. * * @since 2.3 */ @Override public void serializeAsOmittedField(Object bean, JsonGenerator gen, SerializerProvider prov) throws Exception { if (!gen.canOmitFields()) { gen.writeOmittedField(_name.getValue()); } } /** * Alternative to {@link #serializeAsField} that is used when a POJO * is serialized as JSON Array; the difference is that no field names * are written. * * @since 2.3 */ @Override public void serializeAsElement(Object bean, JsonGenerator gen, SerializerProvider prov) throws Exception { // inlined 'get()' final Object value = (_accessorMethod == null) ? _field.get(bean) : _accessorMethod.invoke(bean); if (value == null) { // nulls need specialized handling

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> if (_nullSerializer != null) { _nullSerializer.serialize(null, gen, prov); } else { // can NOT suppress entries in tabular output gen.writeNull(); } return; } // otherwise find serializer to use JsonSerializer<Object> ser = _serializer; if (ser == null) { Class<?> cls = value.getClass(); PropertySerializerMap map = _dynamicSerializers; ser = map.serializerFor(cls); if (ser == null) { ser = _findAndAddDynamic(map, cls, prov); } } // and then see if we must suppress certain values (default, empty) if (_suppressableValue != null) { if (MARKER_FOR_EMPTY == _suppressableValue) { if (ser.isEmpty(prov, value)) { // can NOT suppress entries in tabular output serializeAsPlaceholder(bean, gen, prov); return; } } else if (_suppressableValue.equals(value)) { // can NOT suppress entries in tabular output serializeAsPlaceholder(bean, gen, prov); return; } } // For non-nulls: simple check for direct cycles if (value == bean) { if (_handleSelfReference(bean, gen, prov, ser)) { return; } } if (_typeSerializer == null) { ser.serialize(value, gen, prov); } else { ser.serializeWithType(value, gen, prov, _typeSerializer); } } /** * Method called to serialize a placeholder used in tabular output when * real value is not to be included (is filtered out), but when we need * an entry so that field indexes will not be off. Typically this should * output null or empty String, depending on datatype. * * @since 2.1 */ @Override public void serializeAsPlaceholder(Object bean, JsonGenerator gen, SerializerProvider prov) throws Exception { if (_nullSerializer != null) { _nullSerializer.serialize(null, gen, prov); } else { gen.writeNull(); } } /* /********************************************************** /* PropertyWriter methods (schema generation) /********************************************************** */ // Also part of BeanProperty implementation @Override public void depositSchema

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> '").append(getName()).append("' ("); if (_accessorMethod != null) { sb.append("via method ").append(_accessorMethod.getDeclaringClass().getName()).append("#").append(_accessorMethod.getName()); } else if (_field != null) { sb.append("field \"").append(_field.getDeclaringClass().getName()).append("#").append(_field.getName()); } else { sb.append("virtual"); } if (_serializer == null) { sb.append(", no static serializer"); } else { sb.append(", static serializer of type "+_serializer.getClass().getName()); } sb.append(')'); return sb.toString(); } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std; import java.io.IOException; import java.util.UUID; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.util.TokenBuffer; /** * Specialized {@link JsonSerializer} to output {@link java.util.UUID}s. * Beyond optimized access and writing of textual representation (which * is the default handling in most cases), it will alternatively * allow serialization using raw binary output (as 16-byte block) * if underlying data format has efficient means to access that. */ @SuppressWarnings("serial") public class UUIDSerializer extends StdScalarSerializer<UUID> { final static char[] HEX_CHARS = "0123456789abcdef".toCharArray(); public UUIDSerializer() { super(UUID.class); } @Override @Deprecated // since 2.5 public boolean isEmpty(UUID value) { return isEmpty(null, value); } @Override public boolean isEmpty(SerializerProvider prov, UUID value) { if (value == null) { return true; } // Null UUID is empty, so... if (value.getLeastSignificantBits() == 0L && value.getMostSignificantBits() == 0L) { return true; } return false; } @Override public void serialize(UUID value, JsonGenerator gen, SerializerProvider provider) throws IOException { // First: perhaps we could serialize it as raw binary data? if (gen.canWriteBinaryNatively()) { /* 07-Dec-2013, tatu: One nasty case; that of TokenBuffer. While it can * technically retain binary data, we do not want to do use binary * with it, as that results in UUIDs getting converted to Base64 for * most conversions. */ if (!(gen instanceof TokenBuffer)) { gen.writeBinary(_asBytes(value)); return; } } // UUID.toString() works ok functionally, but we can make it go much faster // (by 4x with micro-benchmark) final char[] ch = new

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.cfg; import java.text.DateFormat; import java.util.Locale; import java.util.Map; import java.util.TimeZone; import com.fasterxml.jackson.annotation.JsonAutoDetect; import com.fasterxml.jackson.annotation.PropertyAccessor; import com.fasterxml.jackson.core.Base64Variant; import com.fasterxml.jackson.databind.AnnotationIntrospector; import com.fasterxml.jackson.databind.MapperFeature; import com.fasterxml.jackson.databind.PropertyNamingStrategy; import com.fasterxml.jackson.databind.introspect.ClassIntrospector; import com.fasterxml.jackson.databind.introspect.VisibilityChecker; import com.fasterxml.jackson.databind.jsontype.SubtypeResolver; import com.fasterxml.jackson.databind.jsontype.TypeResolverBuilder; import com.fasterxml.jackson.databind.type.ClassKey; import com.fasterxml.jackson.databind.type.TypeFactory; public abstract class MapperConfigBase<CFG extends ConfigFeature, T extends MapperConfigBase<CFG,T>> extends MapperConfig<T> implements java.io.Serializable { private static final long serialVersionUID = 6062961959359172474L; private final static int DEFAULT_MAPPER_FEATURES = collectFeatureDefaults(MapperFeature.class); /* /********************************************************** /* Immutable config /********************************************************** */ /** * Mix-in annotation mappings to use, if any: immutable, * can not be changed once defined. */ protected final Map<ClassKey,Class<?>> _mixInAnnotations; /** * Registered concrete subtypes that can be used instead of (or * in addition to) ones declared using annotations. */ protected final SubtypeResolver _subtypeResolver; /** * Explicitly defined root name to use, if any; if empty * String, will disable root-name wrapping; if null, will * use defaults */ protected final String _rootName; /** * View to use for filtering out properties to serialize * or deserialize. * Null if none (will also be assigned null if <code>Object.class</code> * is defined), meaning that all properties are

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std; import java.io.*; import java.lang.reflect.Type; import java.util.*; import java.util.concurrent.atomic.*; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonIntegerFormatVisitor; import com.fasterxml.jackson.databind.ser.BasicSerializerFactory; /** * Class that providers access to serializers user for non-structured JDK types that * are serializer as scalars; some using basic {@link ToStringSerializer}, * others explicit serializers. */ @SuppressWarnings("serial") public class StdJdkSerializers { /** * Method called by {@link BasicSerializerFactory} to access * all serializers this class provides. */ public static Collection<Map.Entry<Class<?>, Object>> all() { HashMap<Class<?>,Object> sers = new HashMap<Class<?>,Object>(); // First things that 'toString()' can handle final ToStringSerializer sls = ToStringSerializer.instance; sers.put(java.net.URL.class, sls); sers.put(java.net.URI.class, sls); sers.put(Currency.class, sls); sers.put(UUID.class, new UUIDSerializer()); sers.put(java.util.regex.Pattern.class, sls); sers.put(Locale.class, sls); // starting with 1.7, use compact String for Locale sers.put(Locale.class, sls); // then atomic types sers.put(AtomicReference.class, AtomicReferenceSerializer.class); sers.put(AtomicBoolean.class, AtomicBooleanSerializer.class); sers.put(AtomicInteger.class, AtomicIntegerSerializer.class); sers.put(AtomicLong.class, AtomicLongSerializer.class); // then other types that need specialized serializers sers.put(File.class, FileSerializer.class); sers.put(Class.class, ClassSerializer.class); // And then some stranger types... not 100%

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> they are needed but: sers.put(Void.class, NullSerializer.instance); sers.put(Void.TYPE, NullSerializer.instance); return sers.entrySet(); } /* /********************************************************** /* Serializers for atomic types /********************************************************** */ public static class AtomicBooleanSerializer extends StdScalarSerializer<AtomicBoolean> { public AtomicBooleanSerializer() { super(AtomicBoolean.class, false); } @Override public void serialize(AtomicBoolean value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { jgen.writeBoolean(value.get()); } @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) { return createSchemaNode("boolean", true); } @Override public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException { visitor.expectBooleanFormat(typeHint); } } public static class AtomicIntegerSerializer extends StdScalarSerializer<AtomicInteger> { public AtomicIntegerSerializer() { super(AtomicInteger.class, false); } @Override public void serialize(AtomicInteger value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { jgen.writeNumber(value.get()); } @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) { return createSchemaNode("integer", true); } @Override public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException { JsonIntegerFormatVisitor v2 = visitor.expectIntegerFormat(typeHint); if (v2 != null) { v2.numberType(JsonParser.NumberType.INT); } } } public static class AtomicLongSerializer extends StdScalarSerializer<AtomicLong> { public AtomicLongSerializer() { super(AtomicLong.class, false); } @Override public void serialize(AtomicLong value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { jgen.writeNumber(value.get()); } @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) { return createSchemaNode("integer", true); } @Override public void acceptJsonFormatVisitor(JsonFormatVisitor

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>Wrapper visitor, JavaType typeHint) throws JsonMappingException { JsonIntegerFormatVisitor v2 = visitor.expectIntegerFormat(typeHint); if (v2 != null) { v2.numberType(JsonParser.NumberType.LONG); } } } public static class AtomicReferenceSerializer extends StdSerializer<AtomicReference<?>> { public AtomicReferenceSerializer() { super(AtomicReference.class, false); } @Override public void serialize(AtomicReference<?> value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { provider.defaultSerializeValue(value.get(), jgen); } @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) { return createSchemaNode("any", true); } @Override public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException { visitor.expectAnyFormat(typeHint); } } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.introspect; import java.lang.annotation.Annotation; import java.lang.reflect.*; import java.util.*; import com.fasterxml.jackson.databind.AnnotationIntrospector; import com.fasterxml.jackson.databind.introspect.ClassIntrospector.MixInResolver; import com.fasterxml.jackson.databind.util.Annotations; import com.fasterxml.jackson.databind.util.ClassUtil; public final class AnnotatedClass extends Annotated { private final static AnnotationMap[] NO_ANNOTATION_MAPS = new AnnotationMap[0]; /* /********************************************************** /* Configuration /********************************************************** */ /** * Class for which annotations apply, and that owns other * components (constructors, methods) */ final protected Class<?> _class; /** * Ordered set of super classes and interfaces of the * class itself: included in order of precedence */ final protected List<Class<?>> _superTypes; /** * Filter used to determine which annotations to gather; used * to optimize things so that unnecessary annotations are * ignored. */ final protected AnnotationIntrospector _annotationIntrospector; /** * Object that knows mapping of mix-in classes (ones that contain * annotations to add) with their target classes (ones that * get these additional annotations "mixed in"). */ final protected MixInResolver _mixInResolver; /** * Primary mix-in class; one to use for the annotated class * itself. Can be null. */ final protected Class<?> _primaryMixIn; /* /********************************************************** /* Gathered information /********************************************************** */ /** * Combined list of Jackson annotations that the class has, * including inheritable ones from super classes and interfaces */ protected AnnotationMap _classAnnotations; /** * Flag to indicate whether creator information has been resolved * or not. */ protected boolean _creatorsResolved = false; /** * Default constructor of the annotated class, if it has one. */ protected AnnotatedConstructor _defaultConstructor; /** * Single argument constructors the class has, if any. */ protected List<AnnotatedConstructor> _constructors; /** * Single argument static methods that might be usable * as factory

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> methods */ protected List<AnnotatedMethod> _creatorMethods; /** * Member methods of interest; for now ones with 0 or 1 arguments * (just optimization, since others won't be used now) */ protected AnnotatedMethodMap _memberMethods; /** * Member fields of interest: ones that are either public, * or have at least one annotation. */ protected List<AnnotatedField> _fields; /* /********************************************************** /* Life-cycle /********************************************************** */ /** * Constructor will not do any initializations, to allow for * configuring instances differently depending on use cases */ private AnnotatedClass(Class<?> cls, List<Class<?>> superTypes, AnnotationIntrospector aintr, MixInResolver mir, AnnotationMap classAnnotations) { _class = cls; _superTypes = superTypes; _annotationIntrospector = aintr; _mixInResolver = mir; _primaryMixIn = (_mixInResolver == null) ? null : _mixInResolver.findMixInClassFor(_class); _classAnnotations = classAnnotations; } @Override public AnnotatedClass withAnnotations(AnnotationMap ann) { return new AnnotatedClass(_class, _superTypes, _annotationIntrospector, _mixInResolver, ann); } /** * Factory method that instantiates an instance. Returned instance * will only be initialized with class annotations, but not with * any method information. */ public static AnnotatedClass construct(Class<?> cls, AnnotationIntrospector aintr, MixInResolver mir) { return new AnnotatedClass(cls, ClassUtil.findSuperTypes(cls, null), aintr, mir, null); } /** * Method similar to {@link #construct}, but that will NOT include * information from supertypes; only class itself and any direct * mix-ins it may have. */ public static AnnotatedClass constructWithoutSuperTypes(Class<?> cls, AnnotationIntrospector aintr, MixInResolver mir) { return new AnnotatedClass(cls, Collections.<Class<?>>emptyList(), aintr, mir, null); } /* /********************************************************** /* Annotated impl /********************************************************** */ @Override public Class<?> getAnnotated

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>() { return _class; } @Override public int getModifiers() { return _class.getModifiers(); } @Override public String getName() { return _class.getName(); } @Override public <A extends Annotation> A getAnnotation(Class<A> acls) { if (_classAnnotations == null) { resolveClassAnnotations(); } return _classAnnotations.get(acls); } @Override public Type getGenericType() { return _class; } @Override public Class<?> getRawType() { return _class; } @Override public Iterable<Annotation> annotations() { if (_classAnnotations == null) { resolveClassAnnotations(); } return _classAnnotations.annotations(); } @Override protected AnnotationMap getAllAnnotations() { if (_classAnnotations == null) { resolveClassAnnotations(); } return _classAnnotations; } /* /********************************************************** /* Public API, generic accessors /********************************************************** */ public Annotations getAnnotations() { if (_classAnnotations == null) { resolveClassAnnotations(); } return _classAnnotations; } public boolean hasAnnotations() { if (_classAnnotations == null) { resolveClassAnnotations(); } return _classAnnotations.size() > 0; } public AnnotatedConstructor getDefaultConstructor() { if (!_creatorsResolved) { resolveCreators(); } return _defaultConstructor; } public List<AnnotatedConstructor> getConstructors() { if (!_creatorsResolved) { resolveCreators(); } return _constructors; } public List<AnnotatedMethod> getStaticMethods() { if (!_creatorsResolved) { resolveCreators(); } return _creatorMethods; } public Iterable<AnnotatedMethod> memberMethods() { if (_memberMethods == null) { resolveMemberMethods(); } return _memberMethods; } public int getMemberMethodCount() { if (_memberMethods == null) { resolveMemberMethods(); } return _memberMethods.size(); } public AnnotatedMethod findMethod(String name, Class<?>[] paramTypes) { if (_memberMethods == null) { resolveMemberMethods(); } return _memberMethods.find(name, param

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>Types); } public int getFieldCount() { if (_fields == null) { resolveFields(); } return _fields.size(); } public Iterable<AnnotatedField> fields() { if (_fields == null) { resolveFields(); } return _fields; } /* /********************************************************** /* Public API, main-level resolution methods /********************************************************** */ /** * Initialization method that will recursively collect Jackson * annotations for this class and all super classes and * interfaces. */ private void resolveClassAnnotations() { _classAnnotations = new AnnotationMap(); // [JACKSON-659] Should skip processing if annotation processing disabled if (_annotationIntrospector != null) { // add mix-in annotations first (overrides) if (_primaryMixIn != null) { _addClassMixIns(_classAnnotations, _class, _primaryMixIn); } // first, annotations from the class itself: _addAnnotationsIfNotPresent(_classAnnotations, _class.getDeclaredAnnotations()); // and then from super types for (Class<?> cls : _superTypes) { // and mix mix-in annotations in-between _addClassMixIns(_classAnnotations, cls); _addAnnotationsIfNotPresent(_classAnnotations, cls.getDeclaredAnnotations()); } /* and finally... any annotations there might be for plain * old Object.class: separate because for all other purposes * it is just ignored (not included in super types) */ /* 12-Jul-2009, tatu: Should this be done for interfaces too? * For now, yes, seems useful for some cases, and not harmful for any? */ _addClassMixIns(_classAnnotations, Object.class); } } /** * Initialization method that will find out all constructors * and potential static factory methods the class has. */ private void resolveCreators() { // Then see which constructors we have List<AnnotatedConstructor> constructors = null; Constructor<?>[] declaredCtors = _class.getDeclaredConstructors(); for (Constructor<?> ctor : declaredCtors) { if (ctor.getParameterTypes().length == 0) { _defaultConstructor = _constructConstructor(ctor, true); } else { if (constructors == null

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>) { constructors = new ArrayList<AnnotatedConstructor>(Math.max(10, declaredCtors.length)); } constructors.add(_constructConstructor(ctor, false)); } } if (constructors == null) { _constructors = Collections.emptyList(); } else { _constructors = constructors; } // and if need be, augment with mix-ins if (_primaryMixIn != null) { if (_defaultConstructor != null || !_constructors.isEmpty()) { _addConstructorMixIns(_primaryMixIn); } } /* And then... let's remove all constructors that are deemed * ignorable after all annotations have been properly collapsed. */ // 14-Feb-2011, tatu: AnnotationIntrospector is null if annotations not enabled; if so, can skip: if (_annotationIntrospector != null) { if (_defaultConstructor != null) { if (_annotationIntrospector.hasIgnoreMarker(_defaultConstructor)) { _defaultConstructor = null; } } if (_constructors != null) { // count down to allow safe removal for (int i = _constructors.size(); --i >= 0; ) { if (_annotationIntrospector.hasIgnoreMarker(_constructors.get(i))) { _constructors.remove(i); } } } } List<AnnotatedMethod> creatorMethods = null; // Then static methods which are potential factory methods for (Method m : _class.getDeclaredMethods()) { if (!Modifier.isStatic(m.getModifiers())) { continue; } // all factory methods are fine, as per [JACKSON-850] //int argCount = m.getParameterTypes().length; if (creatorMethods == null) { creatorMethods = new ArrayList<AnnotatedMethod>(8); } creatorMethods.add(_constructCreatorMethod(m)); } if (creatorMethods == null) { _creatorMethods = Collections.emptyList(); } else { _creatorMethods = creatorMethods; // mix-ins to mix in? if (_primaryMixIn != null) { _addFactoryMixIns(_primaryMixIn); } // anything to ignore at this point? if (_annotationIntrospector != null

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>) { // count down to allow safe removal for (int i = _creatorMethods.size(); --i >= 0; ) { if (_annotationIntrospector.hasIgnoreMarker(_creatorMethods.get(i))) { _creatorMethods.remove(i); } } } } _creatorsResolved = true; } /** * Method for resolving member method information: aggregating all non-static methods * and combining annotations (to implement method-annotation inheritance) * * @param methodFilter Filter used to determine which methods to include */ private void resolveMemberMethods() { _memberMethods = new AnnotatedMethodMap(); AnnotatedMethodMap mixins = new AnnotatedMethodMap(); // first: methods from the class itself _addMemberMethods(_class, _memberMethods, _primaryMixIn, mixins); // and then augment these with annotations from super-types: for (Class<?> cls : _superTypes) { Class<?> mixin = (_mixInResolver == null) ? null : _mixInResolver.findMixInClassFor(cls); _addMemberMethods(cls, _memberMethods, mixin, mixins); } // Special case: mix-ins for Object.class? (to apply to ALL classes) if (_mixInResolver != null) { Class<?> mixin = _mixInResolver.findMixInClassFor(Object.class); if (mixin != null) { _addMethodMixIns(_class, _memberMethods, mixin, mixins); } } /* Any unmatched mix-ins? Most likely error cases (not matching * any method); but there is one possible real use case: * exposing Object#hashCode (alas, Object#getClass can NOT be * exposed, see [JACKSON-140]) */ // 14-Feb-2011, tatu: AnnotationIntrospector is null if annotations not enabled; if so, can skip: if (_annotationIntrospector != null) { if (!mixins.isEmpty()) { Iterator<AnnotatedMethod> it = mixins.iterator(); while (it.hasNext()) { AnnotatedMethod mixIn = it.next(); try { Method m = Object.class.getDeclaredMethod(mixIn.getName(), mixIn.getRawParameterTypes());

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> if (m != null) { AnnotatedMethod am = _constructMethod(m); _addMixOvers(mixIn.getAnnotated(), am, false); _memberMethods.add(am); } } catch (Exception e) { } } } } } /** * Method that will collect all member (non-static) fields * that are either public, or have at least a single annotation * associated with them. */ private void resolveFields() { Map<String,AnnotatedField> foundFields = _findFields(_class, null); if (foundFields == null || foundFields.size() == 0) { _fields = Collections.emptyList(); } else { _fields = new ArrayList<AnnotatedField>(foundFields.size()); _fields.addAll(foundFields.values()); } } /* /********************************************************** /* Helper methods for resolving class annotations /* (resolution consisting of inheritance, overrides, /* and injection of mix-ins as necessary) /********************************************************** */ /** * Helper method for adding any mix-in annotations specified * class might have. */ protected void _addClassMixIns(AnnotationMap annotations, Class<?> toMask) { if (_mixInResolver != null) { _addClassMixIns(annotations, toMask, _mixInResolver.findMixInClassFor(toMask)); } } protected void _addClassMixIns(AnnotationMap annotations, Class<?> toMask, Class<?> mixin) { if (mixin == null) { return; } // Ok, first: annotations from mix-in class itself: _addAnnotationsIfNotPresent(annotations, mixin.getDeclaredAnnotations()); /* And then from its supertypes, if any. But note that we will * only consider super-types up until reaching the masked * class (if found); this because often mix-in class * is a sub-class (for convenience reasons). And if so, we * absolutely must NOT include super types of masked class, * as that would inverse precedence of annotations. */ for (Class<?> parent : ClassUtil.findSuperTypes(mixin, toMask)) { _addAnnotationsIfNotPresent(annotations, parent.getDeclaredAnnotations()); } } /* /********************************************************** /* Helper

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> AnnotatedMethod target, boolean addParamAnnotations) { _addOrOverrideAnnotations(target, mixin.getDeclaredAnnotations()); if (addParamAnnotations) { Annotation[][] pa = mixin.getParameterAnnotations(); for (int i = 0, len = pa.length; i < len; ++i) { for (Annotation a : pa[i]) { target.addOrOverrideParam(i, a); } } } } /** * Method that will add annotations from specified source method to target method, * but only if target does not yet have them. */ protected void _addMixUnders(Method src, AnnotatedMethod target) { _addAnnotationsIfNotPresent(target, src.getDeclaredAnnotations()); } private final boolean _isAnnotationBundle(Annotation ann) { return (_annotationIntrospector != null) && _annotationIntrospector.isAnnotationBundle(ann); } /* /********************************************************** /* Other methods /********************************************************** */ @Override public String toString() { return "[AnnotedClass "+_class.getName()+"]"; } @Override public int hashCode() { return _class.getName().hashCode(); } @Override public boolean equals(Object o) { if (o == this) return true; if (o == null || o.getClass() != getClass()) return false; return ((AnnotatedClass) o)._class == _class; } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std; import java.io.IOException; import java.lang.reflect.Type; import java.text.DateFormat; import com.fasterxml.jackson.core.JsonGenerationException; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.annotation.JacksonStdImpl; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper; /** * Compared to regular {@link java.util.Date} serialization, we do use String * representation here. Why? Basically to truncate of time part, since * that should not be used by plain SQL date. */ @JacksonStdImpl @SuppressWarnings("serial") public class SqlDateSerializer extends DateTimeSerializerBase<java.sql.Date> { public SqlDateSerializer() { /* 12-Apr-2014, tatu: for now, pass explicit 'false' to mean 'not using timestamp', * for backwards compatibility; this differs from other Date/Calendar types. */ this(Boolean.FALSE); } protected SqlDateSerializer(Boolean useTimestamp) { super(java.sql.Date.class, useTimestamp, null); } @Override public SqlDateSerializer withFormat(Boolean timestamp, DateFormat customFormat) { return new SqlDateSerializer(timestamp); } @Override protected long _timestamp(java.sql.Date value) { return (value == null) ? 0L : value.getTime(); } @Override public void serialize(java.sql.Date value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { if (_useTimestamp) { jgen.writeNumber(_timestamp(value)); } else { jgen.writeString(value.toString()); } } @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) { //todo: (ryan) add a format for the date in the schema? return createSchemaNode("string", true); } @Override public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException { _acceptJson

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> PropertyWriter serialization method overrides /********************************************************** */ @Override public void serializeAsField(Object bean, JsonGenerator gen, SerializerProvider prov) throws Exception { // NOTE: mostly copied from base class, but off-lined get() access final Object value = value(bean, gen, prov); if (value == null) { if (_nullSerializer != null) { gen.writeFieldName(_name); _nullSerializer.serialize(null, gen, prov); } return; } JsonSerializer<Object> ser = _serializer; if (ser == null) { Class<?> cls = value.getClass(); PropertySerializerMap m = _dynamicSerializers; ser = m.serializerFor(cls); if (ser == null) { ser = _findAndAddDynamic(m, cls, prov); } } if (_suppressableValue != null) { if (MARKER_FOR_EMPTY == _suppressableValue) { if (ser.isEmpty(prov, value)) { return; } } else if (_suppressableValue.equals(value)) { return; } } if (value == bean) { // simple check for direct cycles // three choices: exception; handled by call; or pass-through if (_handleSelfReference(bean, gen, prov, ser)) { return; } } gen.writeFieldName(_name); if (_typeSerializer == null) { ser.serialize(value, gen, prov); } else { ser.serializeWithType(value, gen, prov, _typeSerializer); } } // This one's fine as-is from base class //public void serializeAsOmittedField(Object bean, JsonGenerator jgen, SerializerProvider prov) throws Exception @Override public void serializeAsElement(Object bean, JsonGenerator gen, SerializerProvider prov) throws Exception { // NOTE: mostly copied from base class, but off-lined get() access final Object value = value(bean, gen, prov); if (value == null) { if (_nullSerializer != null) { _nullSerializer.serialize(null, gen, prov); } else { gen.writeNull(); } return; } JsonSerializer<Object> ser = _serializer; if (ser == null)

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> { Class<?> cls = value.getClass(); PropertySerializerMap map = _dynamicSerializers; ser = map.serializerFor(cls); if (ser == null) { ser = _findAndAddDynamic(map, cls, prov); } } if (_suppressableValue != null) { if (MARKER_FOR_EMPTY == _suppressableValue) { if (ser.isEmpty(prov, value)) { serializeAsPlaceholder(bean, gen, prov); return; } } else if (_suppressableValue.equals(value)) { serializeAsPlaceholder(bean, gen, prov); return; } } if (value == bean) { if (_handleSelfReference(bean, gen, prov, ser)) { return; } } if (_typeSerializer == null) { ser.serialize(value, gen, prov); } else { ser.serializeWithType(value, gen, prov, _typeSerializer); } } // This one's fine as-is from base class //public void serializeAsPlaceholder(Object bean, JsonGenerator jgen, SerializerProvider prov) }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std; import java.io.IOException; import java.lang.reflect.Type; import com.fasterxml.jackson.core.JsonGenerationException; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.JavaType; import com.fasterxml.jackson.databind.JsonMappingException; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.SerializerProvider; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper; /** * Also: default bean access will not do much good with Class.class. But * we can just serialize the class name and that should be enough. */ @SuppressWarnings("serial") public class ClassSerializer extends StdScalarSerializer<Class<?>> { public ClassSerializer() { super(Class.class, false); } @Override public void serialize(Class<?> value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { jgen.writeString(value.getName()); } @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) { return createSchemaNode("string", true); } @Override public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException { visitor.expectStringFormat(typeHint); } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> public final static int TYPE_CURRENCY = 16; final protected int _kind; final protected Class<?> _keyClass; /** * Some types that are deserialized using a helper deserializer. */ protected final FromStringDeserializer<?> _deser; protected StdKeyDeserializer(int kind, Class<?> cls) { this(kind, cls, null); } protected StdKeyDeserializer(int kind, Class<?> cls, FromStringDeserializer<?> deser) { _kind = kind; _keyClass = cls; _deser = deser; } public static StdKeyDeserializer forType(Class<?> raw) { int kind; // first common types: if (raw == String.class || raw == Object.class) { return StringKD.forType(raw); } else if (raw == UUID.class) { kind = TYPE_UUID; } else if (raw == Integer.class) { kind = TYPE_INT; } else if (raw == Long.class) { kind = TYPE_LONG; } else if (raw == Date.class) { kind = TYPE_DATE; } else if (raw == Calendar.class) { kind = TYPE_CALENDAR; // then less common ones... } else if (raw == Boolean.class) { kind = TYPE_BOOLEAN; } else if (raw == Byte.class) { kind = TYPE_BYTE; } else if (raw == Character.class) { kind = TYPE_CHAR; } else if (raw == Short.class) { kind = TYPE_SHORT; } else if (raw == Float.class) { kind = TYPE_FLOAT; } else if (raw == Double.class) { kind = TYPE_DOUBLE; } else if (raw == URI.class) { kind = TYPE_URI; } else if (raw == URL.class) { kind = TYPE_URL; } else if (raw == Class.class) { kind = TYPE_CLASS; } else if (raw == Locale.class) { FromStringDeserializer<?> deser = FromStringDeserializer.findDeserializer(Locale.class); return new StdKeyDeserializer(TYPE_LOCALE, raw, deser); } else if (raw == Currency.class) {

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> FromStringDeserializer<?> deser = FromStringDeserializer.findDeserializer(Currency.class); return new StdKeyDeserializer(TYPE_CURRENCY, raw, deser); } else { return null; } return new StdKeyDeserializer(kind, raw); } @Override public Object deserializeKey(String key, DeserializationContext ctxt) throws IOException, JsonProcessingException { if (key == null) { // is this even legal call? return null; } try { Object result = _parse(key, ctxt); if (result != null) { return result; } } catch (Exception re) { throw ctxt.weirdKeyException(_keyClass, key, "not a valid representation: "+re.getMessage()); } if (_keyClass.isEnum() && ctxt.getConfig().isEnabled(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL)) { return null; } throw ctxt.weirdKeyException(_keyClass, key, "not a valid representation"); } public Class<?> getKeyClass() { return _keyClass; } protected Object _parse(String key, DeserializationContext ctxt) throws Exception { switch (_kind) { case TYPE_BOOLEAN: if ("true".equals(key)) { return Boolean.TRUE; } if ("false".equals(key)) { return Boolean.FALSE; } throw ctxt.weirdKeyException(_keyClass, key, "value not 'true' or 'false'"); case TYPE_BYTE: { int value = _parseInt(key); // as per [JACKSON-804], allow range up to 255, inclusive if (value < Byte.MIN_VALUE || value > 255) { throw ctxt.weirdKeyException(_keyClass, key, "overflow, value can not be represented as 8-bit value"); } return Byte.valueOf((byte) value); } case TYPE_SHORT: { int value = _parseInt(key); if (value < Short.MIN_VALUE || value > Short.MAX_VALUE) { throw ctxt.weirdKeyException(_keyClass, key, "overflow, value can not be represented as 16-bit value"); } return Short.valueOf((

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>" deserializer /********************************************************** */ @JacksonStdImpl final static class StringKD extends StdKeyDeserializer { private static final long serialVersionUID = 1L; private final static StringKD sString = new StringKD(String.class); private final static StringKD sObject = new StringKD(Object.class); private StringKD(Class<?> nominalType) { super(-1, nominalType); } public static StringKD forType(Class<?> nominalType) { if (nominalType == String.class) { return sString; } if (nominalType == Object.class) { return sObject; } return new StringKD(nominalType); } @Override public Object deserializeKey(String key, DeserializationContext ctxt) throws IOException, JsonProcessingException { return key; } } /* /********************************************************** /* Key deserializer implementations; other /********************************************************** */ /** * Key deserializer that wraps a "regular" deserializer (but one * that must recognize FIELD_NAMEs as text!) to reuse existing * handlers as key handlers. */ final static class DelegatingKD extends KeyDeserializer // note: NOT the std one implements java.io.Serializable { private static final long serialVersionUID = 1L; final protected Class<?> _keyClass; protected final JsonDeserializer<?> _delegate; protected DelegatingKD(Class<?> cls, JsonDeserializer<?> deser) { _keyClass = cls; _delegate = deser; } @Override public final Object deserializeKey(String key, DeserializationContext ctxt) throws IOException, JsonProcessingException { if (key == null) { // is this even legal call? return null; } try { // Ugh... should not have to give parser which may or may not be correct one... Object result = _delegate.deserialize(ctxt.getParser(), ctxt); if (result != null) { return result; } } catch (Exception re) { throw ctxt.weirdKeyException(_keyClass, key, "not a valid representation: "+re.getMessage()); } throw ctxt.weirdKeyException(_keyClass, key, "not a valid representation"); } public Class<?> getKeyClass() { return _keyClass; } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser.std; import java.io.IOException; import java.lang.reflect.InvocationTargetException; import com.fasterxml.jackson.databind.JavaType; import com.fasterxml.jackson.databind.JsonDeserializer; import com.fasterxml.jackson.databind.JsonMappingException; import com.fasterxml.jackson.databind.deser.SettableBeanProperty; /** * Intermediate base deserializer class that adds more shared accessor * so that other classes can access information about contained (value) * types */ @SuppressWarnings("serial") public abstract class ContainerDeserializerBase<T> extends StdDeserializer<T> { protected ContainerDeserializerBase(JavaType selfType) { super(selfType); } /** * @deprecated Since 2.3 use one that takes {@link JavaType} */ @Deprecated protected ContainerDeserializerBase(Class<?> selfType) { super(selfType); } /* /********************************************************** /* Overrides /********************************************************** */ @Override public SettableBeanProperty findBackReference(String refName) { JsonDeserializer<Object> valueDeser = getContentDeserializer(); if (valueDeser == null) { throw new IllegalArgumentException("Can not handle managed/back reference '"+refName +"': type: container deserializer of type "+getClass().getName()+" returned null for 'getContentDeserializer()'"); } return valueDeser.findBackReference(refName); } /* /********************************************************** /* Extended API /********************************************************** */ /** * Accessor for declared type of contained value elements; either exact * type, or one of its supertypes. */ public abstract JavaType getContentType(); /** * Accesor for deserializer use for deserializing content values. */ public abstract JsonDeserializer<Object> getContentDeserializer(); /* /********************************************************** /* Shared methods for sub-classes /********************************************************** */ /** * Helper method called by various Map(-like) deserializers. */ protected void wrapAndThrow(Throwable t, Object ref, String key) throws IOException { // to handle StackOverflow: while (t instanceof InvocationTargetException && t.getCause() != null) { t = t.getCause(); } // Errors and "plain

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> public Reference(Object from, int index) { _from = from; _index = index; } public void setFrom(Object o) { _from = o; } public void setFieldName(String n) { _fieldName = n; } public void setIndex(int ix) { _index = ix; } public Object getFrom() { return _from; } public String getFieldName() { return _fieldName; } public int getIndex() { return _index; } @Override public String toString() { StringBuilder sb = new StringBuilder(); Class<?> cls = (_from instanceof Class<?>) ? ((Class<?>)_from) : _from.getClass(); /* Hmmh. Although Class.getName() is mostly ok, it does look * butt-ugly for arrays. So let's use getSimpleName() instead; * but have to prepend package name too. */ Package pkg = cls.getPackage(); if (pkg != null) { sb.append(pkg.getName()); sb.append('.'); } sb.append(cls.getSimpleName()); sb.append('['); if (_fieldName != null) { sb.append('"'); sb.append(_fieldName); sb.append('"'); } else if (_index >= 0) { sb.append(_index); } else { sb.append('?'); } sb.append(']'); return sb.toString(); } } /* /********************************************************** /* State/configuration /********************************************************** */ /** * Path through which problem that triggering throwing of * this exception was reached. */ protected LinkedList<Reference> _path; /* /********************************************************** /* Life-cycle /********************************************************** */ public JsonMappingException(String msg) { super(msg); } public JsonMappingException(String msg, Throwable rootCause) { super(msg, rootCause); } public JsonMappingException(String msg, JsonLocation loc) { super(msg, loc); } public JsonMappingException(String msg, JsonLocation loc, Throwable rootCause) { super(msg, loc, rootCause); } public static JsonMappingException from(JsonParser jp, String msg) { return new JsonMappingException(msg, ((jp == null) ? null : jp.getTokenLocation()));

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> } public static JsonMappingException from(JsonParser jp, String msg, Throwable problem) { return new JsonMappingException(msg, ((jp == null) ? null : jp.getTokenLocation()), problem); } /** * Factory method used when "upgrading" an {@link IOException} into * {@link JsonMappingException}: usually only needed to comply with * a signature. * * @since 2.1 */ public static JsonMappingException fromUnexpectedIOE(IOException src) { return new JsonMappingException("Unexpected IOException (of type " +src.getClass().getName()+"): "+src.getMessage(), (JsonLocation)null, src); } /** * Method that can be called to either create a new JsonMappingException * (if underlying exception is not a JsonMappingException), or augment * given exception with given path/reference information. * * This version of method is called when the reference is through a * non-indexed object, such as a Map or POJO/bean. */ public static JsonMappingException wrapWithPath(Throwable src, Object refFrom, String refFieldName) { return wrapWithPath(src, new Reference(refFrom, refFieldName)); } /** * Method that can be called to either create a new JsonMappingException * (if underlying exception is not a JsonMappingException), or augment * given exception with given path/reference information. * * This version of method is called when the reference is through an * index, which happens with arrays and Collections. */ public static JsonMappingException wrapWithPath(Throwable src, Object refFrom, int index) { return wrapWithPath(src, new Reference(refFrom, index)); } /** * Method that can be called to either create a new JsonMappingException * (if underlying exception is not a JsonMappingException), or augment * given exception with given path/reference information. */ public static JsonMappingException wrapWithPath(Throwable src, Reference ref) { JsonMappingException jme; if (src instanceof JsonMappingException) { jme = (JsonMappingException) src; } else { String msg = src.getMessage(); /* Related to [JACKSON-62], let's use a more meaningful placeholder * if all we have is

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> null */ if (msg == null || msg.length() == 0) { msg = "(was "+src.getClass().getName()+")"; } jme = new JsonMappingException(msg, null, src); } jme.prependPath(ref); return jme; } /* /********************************************************** /* Accessors/mutators /********************************************************** */ /** * Method for accessing full structural path within type hierarchy * down to problematic property. */ public List<Reference> getPath() { if (_path == null) { return Collections.emptyList(); } return Collections.unmodifiableList(_path); } /** * Method for accesing description of path that lead to the * problem that triggered this exception */ public String getPathReference() { return getPathReference(new StringBuilder()).toString(); } public StringBuilder getPathReference(StringBuilder sb) { _appendPathDesc(sb); return sb; } /** * Method called to prepend a reference information in front of * current path */ public void prependPath(Object referrer, String fieldName) { Reference ref = new Reference(referrer, fieldName); prependPath(ref); } /** * Method called to prepend a reference information in front of * current path */ public void prependPath(Object referrer, int index) { Reference ref = new Reference(referrer, index); prependPath(ref); } public void prependPath(Reference r) { if (_path == null) { _path = new LinkedList<Reference>(); } /* Also: let's not increase without bounds. Could choose either * head or tail; tail is easier (no need to ever remove), as * well as potentially more useful so let's use it: */ if (_path.size() < MAX_REFS_TO_LIST) { _path.addFirst(r); } } /* /********************************************************** /* Overridden methods /********************************************************** */ @Override public String getLocalizedMessage() { return _buildMessage(); } /** * Method is overridden so that we can properly inject description * of problem path, if such is defined. */ @Override public String getMessage() { return _buildMessage();

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> } protected String _buildMessage() { /* First: if we have no path info, let's just use parent's * definition as is */ String msg = super.getMessage(); if (_path == null) { return msg; } StringBuilder sb = (msg == null) ? new StringBuilder() : new StringBuilder(msg); /* 18-Feb-2009, tatu: initially there was a linefeed between * message and path reference; but unfortunately many systems * (loggers, junit) seem to assume linefeeds are only added to * separate stack trace. */ sb.append(" (through reference chain: "); sb = getPathReference(sb); sb.append(')'); return sb.toString(); } @Override public String toString() { return getClass().getName()+": "+getMessage(); } /* /********************************************************** /* Internal methods /********************************************************** */ protected void _appendPathDesc(StringBuilder sb) { if (_path == null) { return; } Iterator<Reference> it = _path.iterator(); while (it.hasNext()) { sb.append(it.next().toString()); if (it.hasNext()) { sb.append("->"); } } } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> = property; _dynamicValueSerializers = PropertySerializerMap.emptyForProperties(); } @SuppressWarnings("unchecked") protected MapEntrySerializer(MapEntrySerializer src, BeanProperty property, TypeSerializer vts, JsonSerializer<?> keySer, JsonSerializer<?> valueSer) { super(Map.class, false); _entryType = src._entryType; _keyType = src._keyType; _valueType = src._valueType; _valueTypeIsStatic = src._valueTypeIsStatic; _valueTypeSerializer = src._valueTypeSerializer; _keySerializer = (JsonSerializer<Object>) keySer; _valueSerializer = (JsonSerializer<Object>) valueSer; _dynamicValueSerializers = src._dynamicValueSerializers; _property = src._property; } @Override public ContainerSerializer<?> _withValueTypeSerializer(TypeSerializer vts) { return new MapEntrySerializer(this, _property, vts, _keySerializer, _valueSerializer); } public MapEntrySerializer withResolved(BeanProperty property, JsonSerializer<?> keySerializer, JsonSerializer<?> valueSerializer) { return new MapEntrySerializer(this, property, _valueTypeSerializer, keySerializer, valueSerializer); } @Override public JsonSerializer<?> createContextual(SerializerProvider provider, BeanProperty property) throws JsonMappingException { JsonSerializer<?> ser = null; JsonSerializer<?> keySer = null; final AnnotationIntrospector intr = provider.getAnnotationIntrospector(); final AnnotatedMember propertyAcc = (property == null) ? null : property.getMember(); // First: if we have a property, may have property-annotation overrides if (propertyAcc != null && intr != null) { Object serDef = intr.findKeySerializer(propertyAcc); if (serDef != null) { keySer = provider.serializerInstance(propertyAcc, serDef); } serDef = intr.findContentSerializer(propertyAcc); if (serDef != null) { ser = provider.serializerInstance(propertyAcc, serDef); } } if (ser == null) { ser = _valueSerializer; } // [Issue#124]: May have a content converter ser = findConvertingContentSerializer(provider, property, ser); if (ser == null) { // 30-Sep

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>-2012, tatu: One more thing -- if explicit content type is annotated, // we can consider it a static case as well. // 20-Aug-2013, tatu: Need to avoid trying to access serializer for java.lang.Object tho if ((_valueTypeIsStatic && _valueType.getRawClass() != Object.class) || hasContentTypeAnnotation(provider, property)) { ser = provider.findValueSerializer(_valueType, property); } } else { ser = provider.handleSecondaryContextualization(ser, property); } if (keySer == null) { keySer = _keySerializer; } if (keySer == null) { keySer = provider.findKeySerializer(_keyType, property); } else { keySer = provider.handleSecondaryContextualization(keySer, property); } MapEntrySerializer mser = withResolved(property, keySer, ser); // but note: no filtering, ignored entries or sorting (unlike Maps) return mser; } /* /********************************************************** /* Accessors /********************************************************** */ @Override public JavaType getContentType() { return _valueType; } @Override public JsonSerializer<?> getContentSerializer() { return _valueSerializer; } @Override public boolean hasSingleElement(Map.Entry<?,?> value) { return true; } @Override public boolean isEmpty(SerializerProvider prov, Entry<?, ?> value) { return (value == null); } /* /********************************************************** /* Serialization methods /********************************************************** */ @Override public void serialize(Map.Entry<?, ?> value, JsonGenerator gen, SerializerProvider provider) throws IOException { gen.writeStartObject(); // [databind#631]: Assign current value, to be accessible by custom serializers gen.setCurrentValue(value); if (_valueSerializer != null) { serializeUsing(value, gen, provider, _valueSerializer); } else { serializeDynamic(value, gen, provider); } gen.writeEndObject(); } @Override public void serializeWithType(Map.Entry<?, ?> value, JsonGenerator gen, SerializerProvider provider, TypeSerializer typeSer) throws IOException { typeSer.writeTypePrefixForObject

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>(value, gen); // [databind#631]: Assign current value, to be accessible by custom serializers gen.setCurrentValue(value); if (_valueSerializer != null) { serializeUsing(value, gen, provider, _valueSerializer); } else { serializeDynamic(value, gen, provider); } typeSer.writeTypeSuffixForObject(value, gen); } protected void serializeDynamic(Map.Entry<?, ?> value, JsonGenerator jgen, SerializerProvider provider) throws IOException { final JsonSerializer<Object> keySerializer = _keySerializer; final boolean skipNulls = !provider.isEnabled(SerializationFeature.WRITE_NULL_MAP_VALUES); final TypeSerializer vts = _valueTypeSerializer; PropertySerializerMap serializers = _dynamicValueSerializers; Object valueElem = value.getValue(); Object keyElem = value.getKey(); if (keyElem == null) { provider.findNullKeySerializer(_keyType, _property).serialize(null, jgen, provider); } else { // [JACKSON-314] skip entries with null values? if (skipNulls && valueElem == null) return; keySerializer.serialize(keyElem, jgen, provider); } // And then value if (valueElem == null) { provider.defaultSerializeNull(jgen); } else { Class<?> cc = valueElem.getClass(); JsonSerializer<Object> ser = serializers.serializerFor(cc); if (ser == null) { if (_valueType.hasGenericTypes()) { ser = _findAndAddDynamic(serializers, provider.constructSpecializedType(_valueType, cc), provider); } else { ser = _findAndAddDynamic(serializers, cc, provider); } serializers = _dynamicValueSerializers; } try { if (vts == null) { ser.serialize(valueElem, jgen, provider); } else { ser.serializeWithType(valueElem, jgen, provider, vts); } } catch (Exception e) { // [JACKSON-55] Need to add reference information String keyDesc = ""+keyElem; wrapAndThrow(provider, e, value, keyDesc); } } } /** * Method called to

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> * {@link com.fasterxml.jackson.databind.ser.ResolvableSerializer} and * {@link com.fasterxml.jackson.databind.ser.ContextualSerializer} * are implemented, resolution of serializers occurs before * contextualization. */ public abstract class JsonSerializer<T> implements JsonFormatVisitable // since 2.1 { /* /********************************************************** /* Fluent factory methods for constructing decorated versions /********************************************************** */ /** * Method that will return serializer instance that produces * "unwrapped" serialization, if applicable for type being * serialized (which is the case for some serializers * that produce JSON Objects as output). * If no unwrapped serializer can be constructed, will simply * return serializer as-is. *<p> * Default implementation just returns serializer as-is, * indicating that no unwrapped variant exists * * @param unwrapper Name transformation to use to convert between names * of unwrapper properties */ public JsonSerializer<T> unwrappingSerializer(NameTransformer unwrapper) { return this; } /** * Method that can be called to try to replace serializer this serializer * delegates calls to. If not supported (either this serializer does not * delegate anything; or it does not want any changes), should either * throw {@link UnsupportedOperationException} (if operation does not * make sense or is not allowed); or return this serializer as is. * * @since 2.1 */ public JsonSerializer<T> replaceDelegatee(JsonSerializer<?> delegatee) { throw new UnsupportedOperationException(); } /* /********************************************************** /* Serialization methods /********************************************************** */ /** * Method that can be called to ask implementation to serialize * values of type this serializer handles. * * @param value Value to serialize; can <b>not</b> be null. * @param gen Generator used to output resulting Json content * @param serializers Provider that can be used to get serializers for * serializing Objects value contains, if any. */ public abstract void serialize(T value, JsonGenerator gen, SerializerProvider serializers) throws IOException, JsonProcessingException; /** * Method that can be called to ask implementation to serialize * values of type this serializer handles, using specified type serializer * for embedding necessary type information.

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> *<p> * Default implementation will throw {@link UnsupportedOperationException} * to indicate that proper type handling needs to be implemented. *<p> * For simple datatypes written as a single scalar value (JSON String, Number, Boolean), * implementation would look like: *<pre> * // note: method to call depends on whether this type is serialized as JSON scalar, object or Array! * typeSer.writeTypePrefixForScalar(value, gen); * serialize(value, gen, provider); * typeSer.writeTypeSuffixForScalar(value, gen); *</pre> * and implementations for type serialized as JSON Arrays or Objects would differ slightly, * as <code>START-ARRAY>/<code>END-ARRAY</code> and * <code>START-OBJECT>/<code>END-OBJECT</code> pairs * need to be properly handled with respect to serializing of contents. * * @param value Value to serialize; can <b>not</b> be null. * @param gen Generator used to output resulting Json content * @param serializers Provider that can be used to get serializers for * serializing Objects value contains, if any. * @param typeSer Type serializer to use for including type information */ public void serializeWithType(T value, JsonGenerator gen, SerializerProvider serializers, TypeSerializer typeSer) throws IOException { Class<?> clz = handledType(); if (clz == null) { clz = value.getClass(); } throw serializers.mappingException("Type id handling not implemented for type %s (by serializer of type %s)", clz.getName(), getClass().getName()); } /* /********************************************************** /* Other accessors /********************************************************** */ /** * Method for accessing type of Objects this serializer can handle. * Note that this information is not guaranteed to be exact -- it * may be a more generic (super-type) -- but it should not be * incorrect (return a non-related type). *<p> * Default implementation will return null, which essentially means * same as returning <code>Object.class</code> would; that is, that * nothing is known about handled type. *<p> */ public Class<T> handledType() { return

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.impl; import java.io.IOException; import java.util.*; import com.fasterxml.jackson.core.JsonGenerationException; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.annotation.JacksonStdImpl; import com.fasterxml.jackson.databind.jsontype.TypeSerializer; import com.fasterxml.jackson.databind.ser.ContainerSerializer; import com.fasterxml.jackson.databind.ser.std.AsArraySerializerBase; /** * This is an optimized serializer for Lists that can be efficiently * traversed by index (as opposed to others, such as {@link LinkedList} * that can not}. */ @JacksonStdImpl public final class IndexedListSerializer extends AsArraySerializerBase<List<?>> { private static final long serialVersionUID = 1L; public IndexedListSerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts, BeanProperty property, JsonSerializer<Object> valueSerializer) { super(List.class, elemType, staticTyping, vts, property, valueSerializer); } public IndexedListSerializer(IndexedListSerializer src, BeanProperty property, TypeSerializer vts, JsonSerializer<?> valueSerializer) { super(src, property, vts, valueSerializer); } @Override public IndexedListSerializer withResolved(BeanProperty property, TypeSerializer vts, JsonSerializer<?> elementSerializer) { return new IndexedListSerializer(this, property, vts, elementSerializer); } /* /********************************************************** /* Accessors /********************************************************** */ @Override public boolean isEmpty(SerializerProvider prov, List<?> value) { return (value == null) || value.isEmpty(); } @Override public boolean hasSingleElement(List<?> value) { return (value.size() == 1); } @Override public ContainerSerializer<?> _withValueTypeSerializer(TypeSerializer vts) { return new IndexedListSerializer(_elementType, _staticTyping, vts, _property, _elementSerializer); } @Override public final void serialize(List<?> value, JsonGenerator jgen, SerializerProvider provider) throws IOException { final int len = value.size();

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> if ((len == 1) && provider.isEnabled(SerializationFeature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED)) { serializeContents(value, jgen, provider); return; } jgen.writeStartArray(len); serializeContents(value, jgen, provider); jgen.writeEndArray(); } @Override public void serializeContents(List<?> value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { if (_elementSerializer != null) { serializeContentsUsing(value, jgen, provider, _elementSerializer); return; } if (_valueTypeSerializer != null) { serializeTypedContents(value, jgen, provider); return; } final int len = value.size(); if (len == 0) { return; } int i = 0; try { PropertySerializerMap serializers = _dynamicSerializers; for (; i < len; ++i) { Object elem = value.get(i); if (elem == null) { provider.defaultSerializeNull(jgen); } else { Class<?> cc = elem.getClass(); JsonSerializer<Object> serializer = serializers.serializerFor(cc); if (serializer == null) { // To fix [JACKSON-508] if (_elementType.hasGenericTypes()) { serializer = _findAndAddDynamic(serializers, provider.constructSpecializedType(_elementType, cc), provider); } else { serializer = _findAndAddDynamic(serializers, cc, provider); } serializers = _dynamicSerializers; } serializer.serialize(elem, jgen, provider); } } } catch (Exception e) { wrapAndThrow(provider, e, value, i); } } public void serializeContentsUsing(List<?> value, JsonGenerator jgen, SerializerProvider provider, JsonSerializer<Object> ser) throws IOException { final int len = value.size(); if (len == 0) { return; } final TypeSerializer typeSer = _valueTypeSerializer; for (int i = 0; i < len; ++i) { Object elem = value.get(i); try { if (elem == null) { provider.

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>defaultSerializeNull(jgen); } else if (typeSer == null) { ser.serialize(elem, jgen, provider); } else { ser.serializeWithType(elem, jgen, provider, typeSer); } } catch (Exception e) { // [JACKSON-55] Need to add reference information wrapAndThrow(provider, e, value, i); } } } public void serializeTypedContents(List<?> value, JsonGenerator jgen, SerializerProvider provider) throws IOException { final int len = value.size(); if (len == 0) { return; } int i = 0; try { final TypeSerializer typeSer = _valueTypeSerializer; PropertySerializerMap serializers = _dynamicSerializers; for (; i < len; ++i) { Object elem = value.get(i); if (elem == null) { provider.defaultSerializeNull(jgen); } else { Class<?> cc = elem.getClass(); JsonSerializer<Object> serializer = serializers.serializerFor(cc); if (serializer == null) { // To fix [JACKSON-508] if (_elementType.hasGenericTypes()) { serializer = _findAndAddDynamic(serializers, provider.constructSpecializedType(_elementType, cc), provider); } else { serializer = _findAndAddDynamic(serializers, cc, provider); } serializers = _dynamicSerializers; } serializer.serializeWithType(elem, jgen, provider, typeSer); } } } catch (Exception e) { // [JACKSON-55] Need to add reference information wrapAndThrow(provider, e, value, i); } } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> serialVersionUID = 1; /** * Set of {@link DeserializationFeature}s enabled. */ protected final int _deserFeatures; /** * Linked list that contains all registered problem handlers. * Implementation as front-added linked list allows for sharing * of the list (tail) without copying the list. */ protected final LinkedNode<DeserializationProblemHandler> _problemHandlers; /** * Factory used for constructing {@link com.fasterxml.jackson.databind.JsonNode} instances. */ protected final JsonNodeFactory _nodeFactory; /** * States of {@link com.fasterxml.jackson.core.JsonParser.Feature}s to enable/disable. */ protected final int _parserFeatures; /** * Bitflag of {@link com.fasterxml.jackson.core.JsonParser.Feature}s to enable/disable */ protected final int _parserFeaturesToChange; /* /********************************************************** /* Life-cycle, constructors /********************************************************** */ /** * Constructor used by ObjectMapper to create default configuration object instance. */ public DeserializationConfig(BaseSettings base, SubtypeResolver str, Map<ClassKey,Class<?>> mixins) { super(base, str, mixins); _deserFeatures = collectFeatureDefaults(DeserializationFeature.class); _nodeFactory = JsonNodeFactory.instance; _problemHandlers = null; _parserFeatures = 0; _parserFeaturesToChange = 0; } private DeserializationConfig(DeserializationConfig src, int mapperFeatures, int deserFeatures, int parserFeatures, int parserFeatureMask) { super(src, mapperFeatures); _deserFeatures = deserFeatures; _nodeFactory = src._nodeFactory; _problemHandlers = src._problemHandlers; _parserFeatures = parserFeatures; _parserFeaturesToChange = parserFeatureMask; } /** * Copy constructor used to create a non-shared instance with given mix-in * annotation definitions and subtype resolver. */ private DeserializationConfig(DeserializationConfig src, SubtypeResolver str) { super(src, str); _deserFeatures = src._deserFeatures; _nodeFactory = src._nodeFactory; _problemHandlers = src._problemHandlers; _parserFeatures = src._parserFeatures; _parserFeaturesToChange =

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> + _index; } @Override public boolean equals(Object o) { if (o == this) return true; if (o == null || o.getClass() != getClass()) return false; AnnotatedParameter other = (AnnotatedParameter) o; return other._owner.equals(_owner) && (other._index == _index); } @Override public String toString() { return "[parameter #"+getIndex()+", annotations: "+_annotations+"]"; } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>processing (ResolvableDeserializer) /********************************************************** */ /** * Method called to finalize setup of this deserializer, * when it is known for which property deserializer is needed * for. */ @Override public CollectionDeserializer createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException { // May need to resolve types for delegate-based creators: JsonDeserializer<Object> delegateDeser = null; if ((_valueInstantiator != null) && _valueInstantiator.canCreateUsingDelegate()) { JavaType delegateType = _valueInstantiator.getDelegateType(ctxt.getConfig()); if (delegateType == null) { throw new IllegalArgumentException("Invalid delegate-creator definition for "+_collectionType +": value instantiator ("+_valueInstantiator.getClass().getName() +") returned true for 'canCreateUsingDelegate()', but null for 'getDelegateType()'"); } delegateDeser = findDeserializer(ctxt, delegateType, property); } // also, often value deserializer is resolved here: JsonDeserializer<?> valueDeser = _valueDeserializer; // #125: May have a content converter valueDeser = findConvertingContentDeserializer(ctxt, property, valueDeser); final JavaType vt = _collectionType.getContentType(); if (valueDeser == null) { valueDeser = ctxt.findContextualValueDeserializer(vt, property); } else { // if directly assigned, probably not yet contextual, so: valueDeser = ctxt.handleSecondaryContextualization(valueDeser, property, vt); } // and finally, type deserializer needs context as well TypeDeserializer valueTypeDeser = _valueTypeDeserializer; if (valueTypeDeser != null) { valueTypeDeser = valueTypeDeser.forProperty(property); } return withResolved(delegateDeser, valueDeser, valueTypeDeser); } /* /********************************************************** /* ContainerDeserializerBase API /********************************************************** */ @Override public JavaType getContentType() { return _collectionType.getContentType(); } @Override public JsonDeserializer<Object> getContentDeserializer() { return _valueDeserializer; } /* /********************************************************** /* JsonDeserializer API /********************************************************** */ @SuppressWarnings("unchecked

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>resolvedForwardReference reference) { if (referringAccumulator == null) { throw JsonMappingException .from(p, "Unresolved forward reference but no identity info", reference); } Referring ref = referringAccumulator.handleUnresolvedReference(reference); reference.getRoid().appendReferring(ref); } catch (Exception e) { throw JsonMappingException.wrapWithPath(e, result, result.size()); } } return result; } @Override public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException { // In future could check current token... for now this should be enough: return typeDeserializer.deserializeTypedFromArray(jp, ctxt); } /** * Helper method called when current token is no START_ARRAY. Will either * throw an exception, or try to handle value as if member of implicit * array, depending on configuration. */ protected final Collection<Object> handleNonArray(JsonParser p, DeserializationContext ctxt, Collection<Object> result) throws IOException { // [JACKSON-526]: implicit arrays from single values? if (!ctxt.isEnabled(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY)) { throw ctxt.mappingException(_collectionType.getRawClass()); } JsonDeserializer<Object> valueDes = _valueDeserializer; final TypeDeserializer typeDeser = _valueTypeDeserializer; JsonToken t = p.getCurrentToken(); Object value; try { if (t == JsonToken.VALUE_NULL) { value = valueDes.getNullValue(); } else if (typeDeser == null) { value = valueDes.deserialize(p, ctxt); } else { value = valueDes.deserializeWithType(p, ctxt, typeDeser); } } catch (Exception e) { // note: pass Object.class, not Object[].class, as we need element type for error info throw JsonMappingException.wrapWithPath(e, Object.class, result.size()); } result.add(value); return result; } public final static class CollectionReferringAccumulator { private final Class<?> _elementType; private final Collection<Object> _result; /** * A list of {@link CollectionRef

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std; import java.io.IOException; import java.util.TimeZone; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.SerializerProvider; import com.fasterxml.jackson.databind.jsontype.TypeSerializer; @SuppressWarnings("serial") public class TimeZoneSerializer extends StdScalarSerializer<TimeZone> { public TimeZoneSerializer() { super(TimeZone.class); } @Override public void serialize(TimeZone value, JsonGenerator jgen, SerializerProvider provider) throws IOException { jgen.writeString(value.getID()); } @Override public void serializeWithType(TimeZone value, JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer) throws IOException { // Better ensure we don't use specific sub-classes: typeSer.writeTypePrefixForScalar(value, jgen, TimeZone.class); serialize(value, jgen, provider); typeSer.writeTypeSuffixForScalar(value, jgen); } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std; import java.io.*; import java.nio.ByteBuffer; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.util.ByteBufferBackedInputStream; @SuppressWarnings("serial") public class ByteBufferSerializer extends StdScalarSerializer<ByteBuffer> { public ByteBufferSerializer() { super(ByteBuffer.class); } @Override public void serialize(ByteBuffer bbuf, JsonGenerator gen, SerializerProvider provider) throws IOException { // first, simple case when wrapping an array... if (bbuf.hasArray()) { gen.writeBinary(bbuf.array(), 0, bbuf.limit()); return; } // the other case is more complicated however. Best to handle with InputStream wrapper. // But should we rewind it; and/or make a copy? ByteBuffer copy = bbuf.asReadOnlyBuffer(); if (copy.position() > 0) { copy.rewind(); } InputStream in = new ByteBufferBackedInputStream(copy); gen.writeBinary(in, copy.remaining()); in.close(); } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser; import java.lang.reflect.Method; import java.util.*; import java.util.concurrent.*; import java.util.concurrent.atomic.AtomicReference; import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.core.JsonLocation; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.cfg.DeserializerFactoryConfig; import com.fasterxml.jackson.databind.cfg.HandlerInstantiator; import com.fasterxml.jackson.databind.deser.impl.CreatorCollector; import com.fasterxml.jackson.databind.deser.std.*; import com.fasterxml.jackson.databind.ext.OptionalHandlerFactory; import com.fasterxml.jackson.databind.introspect.*; import com.fasterxml.jackson.databind.jsontype.NamedType; import com.fasterxml.jackson.databind.jsontype.TypeDeserializer; import com.fasterxml.jackson.databind.jsontype.TypeResolverBuilder; import com.fasterxml.jackson.databind.type.*; import com.fasterxml.jackson.databind.util.ClassUtil; import com.fasterxml.jackson.databind.util.EnumResolver; import com.fasterxml.jackson.databind.util.NameTransformer; import com.fasterxml.jackson.databind.util.TokenBuffer; /** * Abstract factory base class that can provide deserializers for standard * JDK classes, including collection classes and simple heuristics for * "upcasting" common collection interface types * (such as {@link java.util.Collection}). *<p> * Since all simple deserializers are eagerly instantiated, and there is * no additional introspection or customizability of these types, * this factory is stateless. */ @SuppressWarnings("serial") public abstract class BasicDeserializerFactory extends DeserializerFactory implements java.io.Serializable { private final static Class<?> CLASS_OBJECT = Object.class; private final static Class<?> CLASS_STRING = String.class; private final static Class<?> CLASS_CHAR_BUFFER = CharSequence.class; private final static Class<?> CLASS_ITERABLE = Iterable.class; private final static Class<?> CLASS_MAP_ENTRY = Map.Entry.class; /** * We

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> need a placeholder for creator properties that don't have name * but are marked with `@JsonWrapped` annotation. */ protected final static PropertyName UNWRAPPED_CREATOR_PARAM_NAME = new PropertyName("@JsonUnwrapped"); /* We do some defaulting for abstract Map classes and * interfaces, to avoid having to use exact types or annotations in * cases where the most common concrete Maps will do. */ @SuppressWarnings("rawtypes") final static HashMap<String, Class<? extends Map>> _mapFallbacks = new HashMap<String, Class<? extends Map>>(); static { _mapFallbacks.put(Map.class.getName(), LinkedHashMap.class); _mapFallbacks.put(ConcurrentMap.class.getName(), ConcurrentHashMap.class); _mapFallbacks.put(SortedMap.class.getName(), TreeMap.class); _mapFallbacks.put(java.util.NavigableMap.class.getName(), TreeMap.class); _mapFallbacks.put(java.util.concurrent.ConcurrentNavigableMap.class.getName(), java.util.concurrent.ConcurrentSkipListMap.class); } /* We do some defaulting for abstract Collection classes and * interfaces, to avoid having to use exact types or annotations in * cases where the most common concrete Collection will do. */ @SuppressWarnings("rawtypes") final static HashMap<String, Class<? extends Collection>> _collectionFallbacks = new HashMap<String, Class<? extends Collection>>(); static { _collectionFallbacks.put(Collection.class.getName(), ArrayList.class); _collectionFallbacks.put(List.class.getName(), ArrayList.class); _collectionFallbacks.put(Set.class.getName(), HashSet.class); _collectionFallbacks.put(SortedSet.class.getName(), TreeSet.class); _collectionFallbacks.put(Queue.class.getName(), LinkedList.class); // then 1.6 types: /* 17-May-2013, tatu: [Issue#216] Should be fine to use straight Class references EXCEPT * that some godforsaken platforms (... looking at you, Android) do not * include these. So, use "soft" references... */ _collectionFallbacks.put("java.util.Deque", LinkedList

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>.class); _collectionFallbacks.put("java.util.NavigableSet", TreeSet.class); } /* /********************************************************** /* Config /********************************************************** */ /** * Configuration settings for this factory; immutable instance (just like this * factory), new version created via copy-constructor (fluent-style) */ protected final DeserializerFactoryConfig _factoryConfig; /* /********************************************************** /* Life cycle /********************************************************** */ protected BasicDeserializerFactory(DeserializerFactoryConfig config) { _factoryConfig = config; } /** * Method for getting current {@link DeserializerFactoryConfig}. *<p> * Note that since instances are immutable, you can NOT change settings * by accessing an instance and calling methods: this will simply create * new instance of config object. */ public DeserializerFactoryConfig getFactoryConfig() { return _factoryConfig; } protected abstract DeserializerFactory withConfig(DeserializerFactoryConfig config); /* /******************************************************** /* Configuration handling: fluent factories /******************************************************** */ /** * Convenience method for creating a new factory instance with additional deserializer * provider. */ @Override public final DeserializerFactory withAdditionalDeserializers(Deserializers additional) { return withConfig(_factoryConfig.withAdditionalDeserializers(additional)); } /** * Convenience method for creating a new factory instance with additional * {@link KeyDeserializers}. */ @Override public final DeserializerFactory withAdditionalKeyDeserializers(KeyDeserializers additional) { return withConfig(_factoryConfig.withAdditionalKeyDeserializers(additional)); } /** * Convenience method for creating a new factory instance with additional * {@link BeanDeserializerModifier}. */ @Override public final DeserializerFactory withDeserializerModifier(BeanDeserializerModifier modifier) { return withConfig(_factoryConfig.withDeserializerModifier(modifier)); } /** * Convenience method for creating a new factory instance with additional * {@link AbstractTypeResolver}. */ @Override public final DeserializerFactory withAbstractTypeResolver(AbstractTypeResolver resolver) { return withConfig(_factoryConfig.withAbstractTypeResolver(resolver)); } /** * Convenience method for creating a new factory instance with additional * {@link ValueInstantiators}. */ @Override public final DeserializerFactory withValueInstantiators

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> @JsonValueInstantiator before anything else AnnotatedClass ac = beanDesc.getClassInfo(); Object instDef = ctxt.getAnnotationIntrospector().findValueInstantiator(ac); if (instDef != null) { instantiator = _valueInstantiatorInstance(config, ac, instDef); } if (instantiator == null) { /* Second: see if some of standard Jackson/JDK types might provide value * instantiators. */ instantiator = _findStdValueInstantiator(config, beanDesc); if (instantiator == null) { instantiator = _constructDefaultValueInstantiator(ctxt, beanDesc); } } // finally: anyone want to modify ValueInstantiator? if (_factoryConfig.hasValueInstantiators()) { for (ValueInstantiators insts : _factoryConfig.valueInstantiators()) { instantiator = insts.findValueInstantiator(config, beanDesc, instantiator); // let's do sanity check; easier to spot buggy handlers if (instantiator == null) { throw new JsonMappingException("Broken registered ValueInstantiators (of type " +insts.getClass().getName()+"): returned null ValueInstantiator"); } } } // Sanity check: does the chosen instantatior have incomplete creators? if (instantiator.getIncompleteParameter() != null) { final AnnotatedParameter nonAnnotatedParam = instantiator.getIncompleteParameter(); final AnnotatedWithParams ctor = nonAnnotatedParam.getOwner(); throw new IllegalArgumentException("Argument #"+nonAnnotatedParam.getIndex()+" of constructor "+ctor+" has no property name annotation; must have name when multiple-parameter constructor annotated as Creator"); } return instantiator; } private ValueInstantiator _findStdValueInstantiator(DeserializationConfig config, BeanDescription beanDesc) throws JsonMappingException { if (beanDesc.getBeanClass() == JsonLocation.class) { return new JsonLocationInstantiator(); } return null; } /** * Method that will construct standard default {@link ValueInstantiator} * using annotations (like @JsonCreator) and visibility rules */ protected ValueInstantiator _constructDefaultValueInstantiator(DeserializationContext ctxt, BeanDescription beanDesc) throws JsonMappingException { boolean fixAccess = ctxt.canOverrideAccessModifiers();

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> #"+index+" of "+owner +" bound to more than one property; "+defs[index]+" vs "+propDef); } } defs[index] = propDef; } } return result; } public ValueInstantiator _valueInstantiatorInstance(DeserializationConfig config, Annotated annotated, Object instDef) throws JsonMappingException { if (instDef == null) { return null; } ValueInstantiator inst; if (instDef instanceof ValueInstantiator) { return (ValueInstantiator) instDef; } if (!(instDef instanceof Class)) { throw new IllegalStateException("AnnotationIntrospector returned key deserializer definition of type " +instDef.getClass().getName() +"; expected type KeyDeserializer or Class<KeyDeserializer> instead"); } Class<?> instClass = (Class<?>)instDef; if (ClassUtil.isBogusClass(instClass)) { return null; } if (!ValueInstantiator.class.isAssignableFrom(instClass)) { throw new IllegalStateException("AnnotationIntrospector returned Class "+instClass.getName() +"; expected Class<ValueInstantiator>"); } HandlerInstantiator hi = config.getHandlerInstantiator(); if (hi != null) { inst = hi.valueInstantiatorInstance(config, annotated, instClass); if (inst != null) { return inst; } } return (ValueInstantiator) ClassUtil.createInstance(instClass, config.canOverrideAccessModifiers()); } @Deprecated // since 2.5.0, removed from 2.6.0 protected void _addDeserializerConstructors(DeserializationContext ctxt, BeanDescription beanDesc, VisibilityChecker<?> vchecker, AnnotationIntrospector intr, CreatorCollector creators) throws JsonMappingException { _addDeserializerConstructors(ctxt, beanDesc, vchecker, intr, creators, Collections.<AnnotatedWithParams,BeanPropertyDefinition[]>emptyMap()); } protected void _addDeserializerConstructors (DeserializationContext ctxt, BeanDescription beanDesc, VisibilityChecker<?> vchecker, AnnotationIntrospector intr, CreatorCollector creators, Map<AnnotatedWithParams,BeanPropertyDefinition[]> creatorParams) throws JsonMappingException { // First things first: the "default constructor" (zero-arg

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>(); if ((ix == 0) && ClassUtil.isNonStaticInnerClass(ctor.getDeclaringClass())) { throw new IllegalArgumentException("Non-static inner classes like " +ctor.getDeclaringClass().getName()+" can not use @JsonCreator for constructors"); } throw new IllegalArgumentException("Argument #"+ix +" of constructor "+ctor+" has no property name annotation; must have name when multiple-parameter constructor annotated as Creator"); } } } } protected boolean _checkIfCreatorPropertyBased(AnnotationIntrospector intr, AnnotatedWithParams creator, BeanPropertyDefinition propDef) { JsonCreator.Mode mode = intr.findCreatorBinding(creator); if (mode == JsonCreator.Mode.PROPERTIES) { return true; } if (mode == JsonCreator.Mode.DELEGATING) { return false; } // If explicit name, or inject id, property-based if (((propDef != null) && propDef.isExplicitlyNamed()) || (intr.findInjectableValueId(creator.getParameter(0)) != null)) { return true; } if (propDef != null) { // One more thing: if implicit name matches property with a getter // or field, we'll consider it property-based as well String implName = propDef.getName(); if (implName != null && !implName.isEmpty()) { if (propDef.couldSerialize()) { return true; } } } // in absence of everything else, default to delegating return false; } protected boolean _handleSingleArgumentConstructor(DeserializationContext ctxt, BeanDescription beanDesc, VisibilityChecker<?> vchecker, AnnotationIntrospector intr, CreatorCollector creators, AnnotatedConstructor ctor, boolean isCreator, boolean isVisible) throws JsonMappingException { // otherwise either 'simple' number, String, or general delegate: Class<?> type = ctor.getRawParameterType(0); if (type == String.class || type == CharSequence.class) { if (isCreator || isVisible) { creators.addStringCreator(ctor, isCreator); } return true; } if (type == int.class || type == Integer.class) { if (isCreator || isVisible) { creators.addInt

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>Creator(ctor, isCreator); } return true; } if (type == long.class || type == Long.class) { if (isCreator || isVisible) { creators.addLongCreator(ctor, isCreator); } return true; } if (type == double.class || type == Double.class) { if (isCreator || isVisible) { creators.addDoubleCreator(ctor, isCreator); } return true; } if (type == boolean.class || type == Boolean.class) { if (isCreator || isVisible) { creators.addBooleanCreator(ctor, isCreator); } return true; } // Delegating Creator ok iff it has @JsonCreator (etc) if (isCreator) { creators.addDelegatingCreator(ctor, isCreator, null); return true; } return false; } @Deprecated // since 2.5, remove from 2.6 protected void _addDeserializerFactoryMethods(DeserializationContext ctxt, BeanDescription beanDesc, VisibilityChecker<?> vchecker, AnnotationIntrospector intr, CreatorCollector creators) throws JsonMappingException { _addDeserializerFactoryMethods(ctxt, beanDesc, vchecker, intr, creators, Collections.<AnnotatedWithParams,BeanPropertyDefinition[]>emptyMap()); } protected void _addDeserializerFactoryMethods (DeserializationContext ctxt, BeanDescription beanDesc, VisibilityChecker<?> vchecker, AnnotationIntrospector intr, CreatorCollector creators, Map<AnnotatedWithParams,BeanPropertyDefinition[]> creatorParams) throws JsonMappingException { final DeserializationConfig config = ctxt.getConfig(); for (AnnotatedMethod factory : beanDesc.getFactoryMethods()) { final boolean isCreator = intr.hasCreatorAnnotation(factory); final int argCount = factory.getParameterCount(); // zero-arg methods must be annotated; if so, are "default creators" [JACKSON-850] if (argCount == 0) { if (isCreator) { creators.setDefaultCreator(factory); } continue; } final BeanPropertyDefinition[] propDefs = creatorParams.get(factory); // some single-arg factory methods (String, number) are auto-detected if (argCount ==

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>, param, injectId); continue; } } /* 25-Sep-2014, tatu: Actually, we may end up "losing" naming due to higher-priority constructor * (see TestCreators#testConstructorCreator() test). And just to avoid running into that problem, * let's add one more work around */ /* PropertyName name2 = _findExplicitParamName(param, intr); if (name2 != null && !name2.isEmpty()) { // Hmmh. Ok, fine. So what are we to do with it... ? // For now... skip. May need to revisit this, should this become problematic continue main_loop; } */ if (nonAnnotatedParam == null) { nonAnnotatedParam = param; } } final int namedCount = explicitNameCount + implicitNameCount; // Ok: if named or injectable, we have more work to do if (isCreator || explicitNameCount > 0 || injectCount > 0) { // simple case; everything covered: if ((namedCount + injectCount) == argCount) { creators.addPropertyCreator(factory, isCreator, properties); } else if ((explicitNameCount == 0) && ((injectCount + 1) == argCount)) { // [712] secondary: all but one injectable, one un-annotated (un-named) creators.addDelegatingCreator(factory, isCreator, properties); } else { // otherwise, epic fail throw new IllegalArgumentException("Argument #"+nonAnnotatedParam.getIndex() +" of factory method "+factory+" has no property name annotation; must have name when multiple-parameter constructor annotated as Creator"); } } } } protected boolean _handleSingleArgumentFactory(DeserializationConfig config, BeanDescription beanDesc, VisibilityChecker<?> vchecker, AnnotationIntrospector intr, CreatorCollector creators, AnnotatedMethod factory, boolean isCreator) throws JsonMappingException { Class<?> type = factory.getRawParameterType(0); if (type == String.class || type == CharSequence.class) { if (isCreator || vchecker.isCreatorVisible(factory)) { creators.addStringCreator(factory, isCreator); } return true; }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> if (type == int.class || type == Integer.class) { if (isCreator || vchecker.isCreatorVisible(factory)) { creators.addIntCreator(factory, isCreator); } return true; } if (type == long.class || type == Long.class) { if (isCreator || vchecker.isCreatorVisible(factory)) { creators.addLongCreator(factory, isCreator); } return true; } if (type == double.class || type == Double.class) { if (isCreator || vchecker.isCreatorVisible(factory)) { creators.addDoubleCreator(factory, isCreator); } return true; } if (type == boolean.class || type == Boolean.class) { if (isCreator || vchecker.isCreatorVisible(factory)) { creators.addBooleanCreator(factory, isCreator); } return true; } if (isCreator) { creators.addDelegatingCreator(factory, isCreator, null); return true; } return false; } /** * Method that will construct a property object that represents * a logical property passed via Creator (constructor or static * factory method) */ protected CreatorProperty constructCreatorProperty(DeserializationContext ctxt, BeanDescription beanDesc, PropertyName name, int index, AnnotatedParameter param, Object injectableValueId) throws JsonMappingException { final DeserializationConfig config = ctxt.getConfig(); final AnnotationIntrospector intr = ctxt.getAnnotationIntrospector(); PropertyMetadata metadata; { if (intr == null) { metadata = PropertyMetadata.STD_REQUIRED_OR_OPTIONAL; } else { Boolean b = intr.hasRequiredMarker(param); boolean req = (b != null && b.booleanValue()); String desc = intr.findPropertyDescription(param); Integer idx = intr.findPropertyIndex(param); String def = intr.findPropertyDefaultValue(param); metadata = PropertyMetadata.construct(req, desc, idx, def); } } JavaType t0 = config.getTypeFactory().constructType(param.getParameterType(), beanDesc.bindingsForBeanType()); BeanProperty.Std property = new BeanProperty.Std(name, t0,

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> null; } protected PropertyName _findImplicitParamName(AnnotatedParameter param, AnnotationIntrospector intr) { String str = intr.findImplicitPropertyName(param); if (str != null && !str.isEmpty()) { return new PropertyName(str); } return null; } protected boolean _hasExplicitParamName(AnnotatedParameter param, AnnotationIntrospector intr) { if (param != null && intr != null) { PropertyName n = intr.findNameForDeserialization(param); return (n != null) && n.hasSimpleName(); } return false; } /* /********************************************************** /* JsonDeserializerFactory impl: array deserializers /********************************************************** */ @Override public JsonDeserializer<?> createArrayDeserializer(DeserializationContext ctxt, ArrayType type, final BeanDescription beanDesc) throws JsonMappingException { final DeserializationConfig config = ctxt.getConfig(); JavaType elemType = type.getContentType(); // Very first thing: is deserializer hard-coded for elements? JsonDeserializer<Object> contentDeser = elemType.getValueHandler(); // Then optional type info: if type has been resolved, we may already know type deserializer: TypeDeserializer elemTypeDeser = elemType.getTypeHandler(); // but if not, may still be possible to find: if (elemTypeDeser == null) { elemTypeDeser = findTypeDeserializer(config, elemType); } // 23-Nov-2010, tatu: Custom array deserializer? JsonDeserializer<?> deser = _findCustomArrayDeserializer(type, config, beanDesc, elemTypeDeser, contentDeser); if (deser == null) { if (contentDeser == null) { Class<?> raw = elemType.getRawClass(); if (elemType.isPrimitive()) { return PrimitiveArrayDeserializers.forType(raw); } else if (raw == String.class) { return StringArrayDeserializer.instance; } } deser = new ObjectArrayDeserializer(type, contentDeser, elemTypeDeser); } // and then new with 2.2: ability to post-process it too (Issue#120) if (_factoryConfig.hasDeserializerModifiers()) { for (BeanDeserializerModifier

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> mod : _factoryConfig.deserializerModifiers()) { deser = mod.modifyArrayDeserializer(config, type, beanDesc, deser); } } return deser; } /* /********************************************************** /* JsonDeserializerFactory impl: Collection(-like) deserializers /********************************************************** */ @Override public JsonDeserializer<?> createCollectionDeserializer(DeserializationContext ctxt, CollectionType type, BeanDescription beanDesc) throws JsonMappingException { JavaType contentType = type.getContentType(); // Very first thing: is deserializer hard-coded for elements? JsonDeserializer<Object> contentDeser = contentType.getValueHandler(); final DeserializationConfig config = ctxt.getConfig(); // Then optional type info (1.5): if type has been resolved, we may already know type deserializer: TypeDeserializer contentTypeDeser = contentType.getTypeHandler(); // but if not, may still be possible to find: if (contentTypeDeser == null) { contentTypeDeser = findTypeDeserializer(config, contentType); } // 23-Nov-2010, tatu: Custom deserializer? JsonDeserializer<?> deser = _findCustomCollectionDeserializer(type, config, beanDesc, contentTypeDeser, contentDeser); if (deser == null) { Class<?> collectionClass = type.getRawClass(); if (contentDeser == null) { // not defined by annotation // One special type: EnumSet: if (EnumSet.class.isAssignableFrom(collectionClass)) { deser = new EnumSetDeserializer(contentType, null); } } } /* One twist: if we are being asked to instantiate an interface or * abstract Collection, we need to either find something that implements * the thing, or give up. * * Note that we do NOT try to guess based on secondary interfaces * here; that would probably not work correctly since casts would * fail later on (as the primary type is not the interface we'd * be implementing) */ if (deser == null) { if (type.isInterface() || type.isAbstract()) { CollectionType implType = _mapAbstractCollectionType(type, config); if (implType == null) { // [Issue#292]: Actually, may be fine, but only if polymorphich

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> deser enabled if (type.getTypeHandler() == null) { throw new IllegalArgumentException("Can not find a deserializer for non-concrete Collection type "+type); } deser = AbstractDeserializer.constructForNonPOJO(beanDesc); } else { type = implType; // But if so, also need to re-check creators... beanDesc = config.introspectForCreation(type); } } if (deser == null) { ValueInstantiator inst = findValueInstantiator(ctxt, beanDesc); if (!inst.canCreateUsingDefault()) { // [Issue#161]: No default constructor for ArrayBlockingQueue... if (type.getRawClass() == ArrayBlockingQueue.class) { return new ArrayBlockingQueueDeserializer(type, contentDeser, contentTypeDeser, inst, null); } } // 13-Dec-2010, tatu: Can use more optimal deserializer if content type is String, so: if (contentType.getRawClass() == String.class) { // no value type deserializer because Strings are one of natural/native types: deser = new StringCollectionDeserializer(type, contentDeser, inst); } else { deser = new CollectionDeserializer(type, contentDeser, contentTypeDeser, inst); } } } // and then new with 2.2: ability to post-process it too (Issue#120) if (_factoryConfig.hasDeserializerModifiers()) { for (BeanDeserializerModifier mod : _factoryConfig.deserializerModifiers()) { deser = mod.modifyCollectionDeserializer(config, type, beanDesc, deser); } } return deser; } protected CollectionType _mapAbstractCollectionType(JavaType type, DeserializationConfig config) { Class<?> collectionClass = type.getRawClass(); collectionClass = _collectionFallbacks.get(collectionClass.getName()); if (collectionClass == null) { return null; } return (CollectionType) config.constructSpecializedType(type, collectionClass); } // Copied almost verbatim from "createCollectionDeserializer" -- should try to share more code @Override public JsonDeserializer<?> createCollectionLikeDeserializer(DeserializationContext ctxt, CollectionLikeType type, final BeanDescription beanDesc) throws JsonMappingException

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> = _findCustomMapDeserializer(type, config, beanDesc, keyDes, contentTypeDeser, contentDeser); if (deser == null) { // Value handling is identical for all, but EnumMap requires special handling for keys Class<?> mapClass = type.getRawClass(); if (EnumMap.class.isAssignableFrom(mapClass)) { Class<?> kt = keyType.getRawClass(); if (kt == null || !kt.isEnum()) { throw new IllegalArgumentException("Can not construct EnumMap; generic (key) type not available"); } deser = new EnumMapDeserializer(type, null, contentDeser, contentTypeDeser); } // Otherwise, generic handler works ok. /* But there is one more twist: if we are being asked to instantiate * an interface or abstract Map, we need to either find something * that implements the thing, or give up. * * Note that we do NOT try to guess based on secondary interfaces * here; that would probably not work correctly since casts would * fail later on (as the primary type is not the interface we'd * be implementing) */ if (deser == null) { if (type.isInterface() || type.isAbstract()) { @SuppressWarnings("rawtypes") Class<? extends Map> fallback = _mapFallbacks.get(mapClass.getName()); if (fallback != null) { mapClass = fallback; type = (MapType) config.constructSpecializedType(type, mapClass); // But if so, also need to re-check creators... beanDesc = config.introspectForCreation(type); } else { // [Issue#292]: Actually, may be fine, but only if polymorphich deser enabled if (type.getTypeHandler() == null) { throw new IllegalArgumentException("Can not find a deserializer for non-concrete Map type "+type); } deser = AbstractDeserializer.constructForNonPOJO(beanDesc); } } if (deser == null) { ValueInstantiator inst = findValueInstantiator(ctxt, beanDesc); MapDeserializer md = new MapDeserializer(type, inst, keyDes, contentDeser, contentTypeDeser); md.setIgnorableProperties(config.getAnnotationIntrospector().findPropertiesTo

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>izers.constructDelegatingKeyDeserializer(config, type, custom); } EnumResolver<?> enumRes = constructEnumResolver(enumClass, config, beanDesc.findJsonValueMethod()); // [JACKSON-193] May have @JsonCreator for static factory method: for (AnnotatedMethod factory : beanDesc.getFactoryMethods()) { if (config.getAnnotationIntrospector().hasCreatorAnnotation(factory)) { int argCount = factory.getParameterCount(); if (argCount == 1) { Class<?> returnType = factory.getRawReturnType(); // usually should be class, but may be just plain Enum<?> (for Enum.valueOf()?) if (returnType.isAssignableFrom(enumClass)) { // note: mostly copied from 'EnumDeserializer.deserializerForCreator(...)' if (factory.getGenericParameterType(0) != String.class) { throw new IllegalArgumentException("Parameter #0 type for factory method ("+factory+") not suitable, must be java.lang.String"); } if (config.canOverrideAccessModifiers()) { ClassUtil.checkAndFixAccess(factory.getMember()); } return StdKeyDeserializers.constructEnumKeyDeserializer(enumRes, factory); } } throw new IllegalArgumentException("Unsuitable method ("+factory+") decorated with @JsonCreator (for Enum type " +enumClass.getName()+")"); } } // [JACKSON-749] Also, need to consider @JsonValue, if one found return StdKeyDeserializers.constructEnumKeyDeserializer(enumRes); } /* /********************************************************** /* Extended API /********************************************************** */ /** * Method called to create a type information deserializer for values of * given non-container property, if one is needed. * If not needed (no polymorphic handling configured for property), should return null. *<p> * Note that this method is only called for non-container bean properties, * and not for values in container types or root values (or container properties) * * @param baseType Declared base type of the value to deserializer (actual * deserializer type will be this type or its subtype) * * @return Type deserializer to use for given base type, if one is needed; null if not. */ public TypeDeserializer findPropertyTypeDeserializer

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>Deserializer<?> findDefaultDeserializer(DeserializationContext ctxt, JavaType type, BeanDescription beanDesc) throws JsonMappingException { Class<?> rawType = type.getRawClass(); // Object ("untyped"), String equivalents: if (rawType == CLASS_OBJECT) { return new UntypedObjectDeserializer(); } if (rawType == CLASS_STRING || rawType == CLASS_CHAR_BUFFER) { return StringDeserializer.instance; } if (rawType == CLASS_ITERABLE) { // [Issue#199]: Can and should 'upgrade' to a Collection type: TypeFactory tf = ctxt.getTypeFactory(); JavaType[] tps = tf.findTypeParameters(type, CLASS_ITERABLE); JavaType elemType = (tps == null || tps.length != 1) ? TypeFactory.unknownType() : tps[0]; CollectionType ct = tf.constructCollectionType(Collection.class, elemType); // Should we re-introspect beanDesc? For now let's not... return createCollectionDeserializer(ctxt, ct, beanDesc); } if (rawType == CLASS_MAP_ENTRY) { final DeserializationConfig config = ctxt.getConfig(); TypeFactory tf = ctxt.getTypeFactory(); JavaType[] tps = tf.findTypeParameters(type, CLASS_MAP_ENTRY); JavaType kt, vt; if (tps == null || tps.length != 2) { kt = vt = TypeFactory.unknownType(); } else { kt = tps[0]; vt = tps[1]; } TypeDeserializer vts = (TypeDeserializer) vt.getTypeHandler(); if (vts == null) { vts = findTypeDeserializer(config, vt); } JsonDeserializer<Object> valueDeser = vt.getValueHandler(); KeyDeserializer keyDes = (KeyDeserializer) kt.getValueHandler(); return new MapEntryDeserializer(type, keyDes, valueDeser, vts); } String clsName = rawType.getName(); if (rawType.isPrimitive() || clsName.startsWith("java.")) { // Primitives/wrappers, other Numbers: JsonDeserializer<?> deser = NumberDeserializers.find(rawType, clsName); if (deser == null) {

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> deser = DateDeserializers.find(rawType, clsName); } if (deser != null) { return deser; } } // and a few Jackson types as well: if (rawType == TokenBuffer.class) { return new TokenBufferDeserializer(); } if (AtomicReference.class.isAssignableFrom(rawType)) { // Must find parameterization TypeFactory tf = ctxt.getTypeFactory(); JavaType[] params = tf.findTypeParameters(type, AtomicReference.class); JavaType referencedType; if (params == null || params.length < 1) { // untyped (raw) referencedType = TypeFactory.unknownType(); } else { referencedType = params[0]; } TypeDeserializer vts = findTypeDeserializer(ctxt.getConfig(), referencedType); BeanDescription refdDesc = ctxt.getConfig().introspectClassAnnotations(referencedType); JsonDeserializer<?> deser = findDeserializerFromAnnotation(ctxt, refdDesc.getClassInfo()); return new AtomicReferenceDeserializer(referencedType, vts, deser); } JsonDeserializer<?> deser = findOptionalStdDeserializer(ctxt, type, beanDesc); if (deser != null) { return deser; } return JdkDeserializers.find(rawType, clsName); } /* /********************************************************** /* Helper methods, finding custom deserializers /********************************************************** */ protected JsonDeserializer<?> _findCustomArrayDeserializer(ArrayType type, DeserializationConfig config, BeanDescription beanDesc, TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer) throws JsonMappingException { for (Deserializers d : _factoryConfig.deserializers()) { JsonDeserializer<?> deser = d.findArrayDeserializer(type, config, beanDesc, elementTypeDeserializer, elementDeserializer); if (deser != null) { return deser; } } return null; } @SuppressWarnings("unchecked") protected JsonDeserializer<Object> _findCustomBeanDeserializer(JavaType type, DeserializationConfig config, BeanDescription beanDesc) throws JsonMappingException { for (Deserializers d : _factoryConfig.deserializers()) { JsonDeserializer<?> deser = d.findBeanDeserializer(type, config, beanDesc); if (deser != null) { return (Json

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std; import java.io.IOException; import java.lang.reflect.Type; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.JavaType; import com.fasterxml.jackson.databind.JsonMappingException; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.SerializerProvider; import com.fasterxml.jackson.databind.annotation.JacksonStdImpl; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper; /** * This is the special serializer for regular {@link java.lang.String}s. *<p> * Since this is one of "native" types, no type information is ever * included on serialization (unlike for most scalar types as of 1.5) */ @JacksonStdImpl public final class StringSerializer extends NonTypedScalarSerializerBase<String> { private static final long serialVersionUID = 1L; public StringSerializer() { super(String.class); } /** * For Strings, both null and Empty String qualify for emptiness. */ @Override @Deprecated public boolean isEmpty(String value) { return (value == null) || (value.length() == 0); } @Override public boolean isEmpty(SerializerProvider prov, String value) { return (value == null) || (value.length() == 0); } @Override public void serialize(String value, JsonGenerator jgen, SerializerProvider provider) throws IOException { jgen.writeString(value); } @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) { return createSchemaNode("string", true); } @Override public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException { if (visitor != null) visitor.expectStringFormat(typeHint); } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser.std; import java.io.IOException; import java.lang.reflect.Array; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.annotation.JacksonStdImpl; import com.fasterxml.jackson.databind.deser.ContextualDeserializer; import com.fasterxml.jackson.databind.jsontype.TypeDeserializer; import com.fasterxml.jackson.databind.type.ArrayType; import com.fasterxml.jackson.databind.util.ObjectBuffer; /** * Basic serializer that can serialize non-primitive arrays. */ @JacksonStdImpl public class ObjectArrayDeserializer extends ContainerDeserializerBase<Object[]> implements ContextualDeserializer { private static final long serialVersionUID = 1L; // // Configuration /** * Full generic type of the array being deserialized */ protected final ArrayType _arrayType; /** * Flag that indicates whether the component type is Object or not. * Used for minor optimization when constructing result. */ protected final boolean _untyped; /** * Type of contained elements: needed for constructing actual * result array */ protected final Class<?> _elementClass; /** * Element deserializer */ protected JsonDeserializer<Object> _elementDeserializer; /** * If element instances have polymorphic type information, this * is the type deserializer that can handle it */ protected final TypeDeserializer _elementTypeDeserializer; /* /********************************************************** /* Life-cycle /********************************************************** */ public ObjectArrayDeserializer(ArrayType arrayType, JsonDeserializer<Object> elemDeser, TypeDeserializer elemTypeDeser) { super(arrayType); _arrayType = arrayType; _elementClass = arrayType.getContentType().getRawClass(); _untyped = (_elementClass == Object.class); _elementDeserializer = elemDeser; _elementTypeDeserializer = elemTypeDeser; } /** * Overridable fluent-factory method used to create contextual instances */ @SuppressWarnings("unchecked") public ObjectArrayDeserializer withDeserializer(TypeDeserializer elemTypeDeser, JsonDeserializer<?> elemDeser) { if ((elemDeser == _elementDeserializer) && (elemTypeDeser ==

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>_STRING_AS_NULL_OBJECT)) { String str = jp.getText(); if (str.length() == 0) { return null; } } // Can we do implicit coercion to a single-element array still? if (!ctxt.isEnabled(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY)) { /* 04-Oct-2009, tatu: One exception; byte arrays are generally * serialized as base64, so that should be handled */ if (jp.getCurrentToken() == JsonToken.VALUE_STRING && _elementClass == Byte.class) { return deserializeFromBase64(jp, ctxt); } throw ctxt.mappingException(_arrayType.getRawClass()); } JsonToken t = jp.getCurrentToken(); Object value; if (t == JsonToken.VALUE_NULL) { value = _elementDeserializer.getNullValue(); } else if (_elementTypeDeserializer == null) { value = _elementDeserializer.deserialize(jp, ctxt); } else { value = _elementDeserializer.deserializeWithType(jp, ctxt, _elementTypeDeserializer); } // Ok: bit tricky, since we may want T[], not just Object[] Object[] result; if (_untyped) { result = new Object[1]; } else { result = (Object[]) Array.newInstance(_elementClass, 1); } result[0] = value; return result; } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std; import java.io.IOException; import java.util.Collection; import java.util.Iterator; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.BeanProperty; import com.fasterxml.jackson.databind.JavaType; import com.fasterxml.jackson.databind.JsonSerializer; import com.fasterxml.jackson.databind.SerializationFeature; import com.fasterxml.jackson.databind.SerializerProvider; import com.fasterxml.jackson.databind.jsontype.TypeSerializer; import com.fasterxml.jackson.databind.ser.ContainerSerializer; import com.fasterxml.jackson.databind.ser.impl.PropertySerializerMap; /** * Fallback serializer for cases where Collection is not known to be * of type for which more specializer serializer exists (such as * index-accessible List). * If so, we will just construct an {@link java.util.Iterator} * to iterate over elements. */ public class CollectionSerializer extends AsArraySerializerBase<Collection<?>> { private static final long serialVersionUID = 1L; /* /********************************************************** /* Life-cycle /********************************************************** */ public CollectionSerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts, BeanProperty property, JsonSerializer<Object> valueSerializer) { super(Collection.class, elemType, staticTyping, vts, property, valueSerializer); } public CollectionSerializer(CollectionSerializer src, BeanProperty property, TypeSerializer vts, JsonSerializer<?> valueSerializer) { super(src, property, vts, valueSerializer); } @Override public ContainerSerializer<?> _withValueTypeSerializer(TypeSerializer vts) { return new CollectionSerializer(_elementType, _staticTyping, vts, _property, _elementSerializer); } @Override public CollectionSerializer withResolved(BeanProperty property, TypeSerializer vts, JsonSerializer<?> elementSerializer) { return new CollectionSerializer(this, property, vts, elementSerializer); } /* /********************************************************** /* Accessors /********************************************************** */ @Override public boolean isEmpty(SerializerProvider prov, Collection<?> value) { return (value == null) || value.isEmpty(); } @Override public boolean hasSingle

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>Element(Collection<?> value) { Iterator<?> it = value.iterator(); if (!it.hasNext()) { return false; } it.next(); return !it.hasNext(); } /* /********************************************************** /* Actual serialization /********************************************************** */ @Override public final void serialize(Collection<?> value, JsonGenerator jgen, SerializerProvider provider) throws IOException { final int len = value.size(); if ((len == 1) && provider.isEnabled(SerializationFeature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED)) { serializeContents(value, jgen, provider); return; } jgen.writeStartArray(len); serializeContents(value, jgen, provider); jgen.writeEndArray(); } @Override public void serializeContents(Collection<?> value, JsonGenerator jgen, SerializerProvider provider) throws IOException { if (_elementSerializer != null) { serializeContentsUsing(value, jgen, provider, _elementSerializer); return; } Iterator<?> it = value.iterator(); if (!it.hasNext()) { return; } PropertySerializerMap serializers = _dynamicSerializers; final TypeSerializer typeSer = _valueTypeSerializer; int i = 0; try { do { Object elem = it.next(); if (elem == null) { provider.defaultSerializeNull(jgen); } else { Class<?> cc = elem.getClass(); JsonSerializer<Object> serializer = serializers.serializerFor(cc); if (serializer == null) { // To fix [JACKSON-508] if (_elementType.hasGenericTypes()) { serializer = _findAndAddDynamic(serializers, provider.constructSpecializedType(_elementType, cc), provider); } else { serializer = _findAndAddDynamic(serializers, cc, provider); } serializers = _dynamicSerializers; } if (typeSer == null) { serializer.serialize(elem, jgen, provider); } else { serializer.serializeWithType(elem, jgen, provider, typeSer); } } ++i; } while (it.hasNext()); } catch (Exception e) { // [JACKSON-55] Need to add reference information wrapAnd

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std; import java.io.IOException; import java.util.*; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.jsontype.TypeSerializer; @SuppressWarnings("serial") public class EnumSetSerializer extends AsArraySerializerBase<EnumSet<? extends Enum<?>>> { public EnumSetSerializer(JavaType elemType, BeanProperty property) { super(EnumSet.class, elemType, true, null, property, null); } public EnumSetSerializer(EnumSetSerializer src, BeanProperty property, TypeSerializer vts, JsonSerializer<?> valueSerializer) { super(src, property, vts, valueSerializer); } @Override public EnumSetSerializer _withValueTypeSerializer(TypeSerializer vts) { // no typing for enums (always "hard" type) return this; } @Override public EnumSetSerializer withResolved(BeanProperty property, TypeSerializer vts, JsonSerializer<?> elementSerializer) { return new EnumSetSerializer(this, property, vts, elementSerializer); } @Override public boolean isEmpty(SerializerProvider prov, EnumSet<? extends Enum<?>> value) { return (value == null) || value.isEmpty(); } @Override public boolean hasSingleElement(EnumSet<? extends Enum<?>> value) { return value.size() == 1; } @Override public final void serialize(EnumSet<? extends Enum<?>> value, JsonGenerator jgen, SerializerProvider provider) throws IOException { final int len = value.size(); if ((len == 1) && provider.isEnabled(SerializationFeature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED)) { serializeContents(value, jgen, provider); return; } jgen.writeStartArray(len); serializeContents(value, jgen, provider); jgen.writeEndArray(); } @Override public void serializeContents(EnumSet<? extends Enum<?>> value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { JsonSerializer<Object> enumSer = _elementSerializer; /* Need to dynamically find instance serializer; unfortunately * that seems to be the only way to figure out

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> ignoreAllUnknown); } protected BeanDeserializer(BeanDeserializerBase src, NameTransformer unwrapper) { super(src, unwrapper); } public BeanDeserializer(BeanDeserializerBase src, ObjectIdReader oir) { super(src, oir); } public BeanDeserializer(BeanDeserializerBase src, HashSet<String> ignorableProps) { super(src, ignorableProps); } @Override public JsonDeserializer<Object> unwrappingDeserializer(NameTransformer unwrapper) { /* bit kludgy but we don't want to accidentally change type; sub-classes * MUST override this method to support unwrapped properties... */ if (getClass() != BeanDeserializer.class) { return this; } /* main thing really is to just enforce ignoring of unknown * properties; since there may be multiple unwrapped values * and properties for all may be interleaved... */ return new BeanDeserializer(this, unwrapper); } @Override public BeanDeserializer withObjectIdReader(ObjectIdReader oir) { return new BeanDeserializer(this, oir); } @Override public BeanDeserializer withIgnorableProperties(HashSet<String> ignorableProps) { return new BeanDeserializer(this, ignorableProps); } @Override protected BeanDeserializerBase asArrayDeserializer() { SettableBeanProperty[] props = _beanProperties.getPropertiesInInsertionOrder(); return new BeanAsArrayDeserializer(this, props); } /* /********************************************************** /* JsonDeserializer implementation /********************************************************** */ /** * Main deserialization method for bean-based objects (POJOs). *<p> * NOTE: was declared 'final' in 2.2; should NOT be to let extensions * like Afterburner change definition. */ @Override public Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { JsonToken t = p.getCurrentToken(); // common case first if (t == JsonToken.START_OBJECT) { // TODO: in 2.6, use 'p.hasTokenId()' if (_vanillaProcessing) { return vanillaDeserialize(p, ctxt, p.nextToken()); } p.nextToken(); if (_objectIdReader != null) { return deserializeWithObjectId(p, ctxt); } return

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>Property(propName); if (creatorProp != null) { // Last creator property to set? Object value = creatorProp.deserialize(p, ctxt); if (buffer.assignParameter(creatorProp.getCreatorIndex(), value)) { p.nextToken(); // to move to following FIELD_NAME/END_OBJECT Object bean; try { bean = creator.build(ctxt, buffer); } catch (Exception e) { wrapAndThrow(e, _beanType.getRawClass(), propName, ctxt); bean = null; // never gets here } if (bean == null) { throw ctxt.instantiationException(_beanType.getRawClass(), "JSON Creator returned null"); } // [databind#631]: Assign current value, to be accessible by custom serializers p.setCurrentValue(bean); // polymorphic? if (bean.getClass() != _beanType.getRawClass()) { return handlePolymorphic(p, ctxt, bean, unknown); } if (unknown != null) { // nope, just extra unknown stuff... bean = handleUnknownProperties(ctxt, bean, unknown); } // or just clean? return deserialize(p, ctxt, bean); } continue; } // Object Id property? if (buffer.readIdProperty(propName)) { continue; } // regular property? needs buffering SettableBeanProperty prop = _beanProperties.find(propName); if (prop != null) { buffer.bufferProperty(prop, prop.deserialize(p, ctxt)); continue; } // As per [JACKSON-313], things marked as ignorable should not be // passed to any setter if (_ignorableProps != null && _ignorableProps.contains(propName)) { handleIgnoredProperty(p, ctxt, handledType(), propName); continue; } // "any property"? if (_anySetter != null) { buffer.bufferAnyProperty(_anySetter, propName, _anySetter.deserialize(p, ctxt)); continue; } // Ok then, let's collect the whole field; name and value if (unknown == null) { unknown = new TokenBuffer(p); } unknown.writeFieldName(propName); unknown

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>.copyCurrentStructure(p); } // We hit END_OBJECT, so: Object bean; try { bean = creator.build(ctxt, buffer); } catch (Exception e) { wrapInstantiationProblem(e, ctxt); bean = null; // never gets here } if (unknown != null) { // polymorphic? if (bean.getClass() != _beanType.getRawClass()) { return handlePolymorphic(null, ctxt, bean, unknown); } // no, just some extra unknown properties return handleUnknownProperties(ctxt, bean, unknown); } return bean; } /* /********************************************************** /* Deserializing when we have to consider an active View /********************************************************** */ protected final Object deserializeWithView(JsonParser p, DeserializationContext ctxt, Object bean, Class<?> activeView) throws IOException { JsonToken t = p.getCurrentToken(); for (; t == JsonToken.FIELD_NAME; t = p.nextToken()) { String propName = p.getCurrentName(); // Skip field name: p.nextToken(); SettableBeanProperty prop = _beanProperties.find(propName); if (prop != null) { if (!prop.visibleInView(activeView)) { p.skipChildren(); continue; } try { prop.deserializeAndSet(p, ctxt, bean); } catch (Exception e) { wrapAndThrow(e, bean, propName, ctxt); } continue; } handleUnknownVanilla(p, ctxt, bean, propName); } return bean; } /* /********************************************************** /* Handling for cases where we have "unwrapped" values /********************************************************** */ /** * Method called when there are declared "unwrapped" properties * which need special handling */ @SuppressWarnings("resource") protected Object deserializeWithUnwrapped(JsonParser p, DeserializationContext ctxt) throws IOException { if (_delegateDeserializer != null) { return _valueInstantiator.createUsingDelegate(ctxt, _delegateDeserializer.deserialize(p, ctxt)); } if (_propertyBasedCreator != null) { return deserializeUsingPropertyBasedWithUnwrapped(p, ctxt); } TokenBuffer tokens = new TokenBuffer(p); tokens

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>_OBJECT Object bean; try { bean = creator.build(ctxt, buffer); } catch (Exception e) { wrapAndThrow(e, _beanType.getRawClass(), propName, ctxt); continue; // never gets here } // [databind#631]: Assign current value, to be accessible by custom serializers p.setCurrentValue(bean); // if so, need to copy all remaining tokens into buffer while (t == JsonToken.FIELD_NAME) { p.nextToken(); // to skip name tokens.copyCurrentStructure(p); t = p.nextToken(); } tokens.writeEndObject(); if (bean.getClass() != _beanType.getRawClass()) { // !!! 08-Jul-2011, tatu: Could probably support; but for now // it's too complicated, so bail out tokens.close(); throw ctxt.mappingException("Can not create polymorphic instances with unwrapped values"); } return _unwrappedPropertyHandler.processUnwrapped(p, ctxt, bean, tokens); } continue; } // Object Id property? if (buffer.readIdProperty(propName)) { continue; } // regular property? needs buffering SettableBeanProperty prop = _beanProperties.find(propName); if (prop != null) { buffer.bufferProperty(prop, prop.deserialize(p, ctxt)); continue; } /* As per [JACKSON-313], things marked as ignorable should not be * passed to any setter */ if (_ignorableProps != null && _ignorableProps.contains(propName)) { handleIgnoredProperty(p, ctxt, handledType(), propName); continue; } tokens.writeFieldName(propName); tokens.copyCurrentStructure(p); // "any property"? if (_anySetter != null) { buffer.bufferAnyProperty(_anySetter, propName, _anySetter.deserialize(p, ctxt)); } } // We hit END_OBJECT, so: Object bean; try { bean = creator.build(ctxt, buffer); } catch (Exception e) { wrapInstantiationProblem(e, ctxt); return null; // never gets here }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>Exception e) { wrapAndThrow(e, bean, propName, ctxt); } continue; } // Unknown: let's call handler method handleUnknownProperty(p, ctxt, bean, propName); } // and when we get this far, let's try finalizing the deal: return ext.complete(p, ctxt, bean); } @SuppressWarnings("resource") protected Object deserializeUsingPropertyBasedWithExternalTypeId(JsonParser p, DeserializationContext ctxt) throws IOException { final ExternalTypeHandler ext = _externalTypeIdHandler.start(); final PropertyBasedCreator creator = _propertyBasedCreator; PropertyValueBuffer buffer = creator.startBuilding(p, ctxt, _objectIdReader); TokenBuffer tokens = new TokenBuffer(p); tokens.writeStartObject(); JsonToken t = p.getCurrentToken(); for (; t == JsonToken.FIELD_NAME; t = p.nextToken()) { String propName = p.getCurrentName(); p.nextToken(); // to point to value // creator property? SettableBeanProperty creatorProp = creator.findCreatorProperty(propName); if (creatorProp != null) { // first: let's check to see if this might be part of value with external type id: if (ext.handlePropertyValue(p, ctxt, propName, buffer)) { ; } else { // Last creator property to set? Object value = creatorProp.deserialize(p, ctxt); if (buffer.assignParameter(creatorProp.getCreatorIndex(), value)) { t = p.nextToken(); // to move to following FIELD_NAME/END_OBJECT Object bean; try { bean = creator.build(ctxt, buffer); } catch (Exception e) { wrapAndThrow(e, _beanType.getRawClass(), propName, ctxt); continue; // never gets here } // if so, need to copy all remaining tokens into buffer while (t == JsonToken.FIELD_NAME) { p.nextToken(); // to skip name tokens.copyCurrentStructure(p); t = p.nextToken(); } if (bean.getClass() != _beanType.getRawClass()) { // !!! 08-Jul-2011, tatu: Could probably support; but for now //

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.impl; import java.io.IOException; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.JsonSerializer; import com.fasterxml.jackson.databind.SerializerProvider; import com.fasterxml.jackson.databind.jsontype.TypeSerializer; /** * Simple serializer that will call configured type serializer, passing * in configured data serializer, and exposing it all as a simple * serializer. */ public final class TypeWrappedSerializer extends JsonSerializer<Object> { final protected TypeSerializer _typeSerializer; final protected JsonSerializer<Object> _serializer; @SuppressWarnings("unchecked") public TypeWrappedSerializer(TypeSerializer typeSer, JsonSerializer<?> ser) { super(); _typeSerializer = typeSer; _serializer = (JsonSerializer<Object>) ser; } @Override public void serialize(Object value, JsonGenerator jgen, SerializerProvider provider) throws IOException { _serializer.serializeWithType(value, jgen, provider, _typeSerializer); } @Override public void serializeWithType(Object value, JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer) throws IOException { /* Is this an erroneous call? For now, let's assume it is not, and * that type serializer is just overridden if so */ _serializer.serializeWithType(value, jgen, provider, typeSer); } @Override public Class<Object> handledType() { return Object.class; } /* /********************************************************** /* Extended API for other core classes /********************************************************** */ public JsonSerializer<Object> valueSerializer() { return _serializer; } public TypeSerializer typeSerializer() { return _typeSerializer; } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind; import java.io.IOException; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.core.format.InputAccessor; import com.fasterxml.jackson.core.format.MatchStrength; /** * Sub-class of {@link JsonFactory} that will create a proper * {@link ObjectCodec} to allow seam-less conversions between * JSON content and Java objects (POJOs). * The only addition to regular {@link JsonFactory} currently * is that {@link ObjectMapper} is constructed and passed as * the codec to use. */ public class MappingJsonFactory extends JsonFactory { // generated for Jackson 2.1.0 private static final long serialVersionUID = -6744103724013275513L; public MappingJsonFactory() { this(null); } public MappingJsonFactory(ObjectMapper mapper) { super(mapper); if (mapper == null) { setCodec(new ObjectMapper(this)); } } /** * We'll override the method to return more specific type; co-variance * helps here */ @Override public final ObjectMapper getCodec() { return (ObjectMapper) _objectCodec; } // @since 2.1 @Override public JsonFactory copy() { _checkInvalidCopy(MappingJsonFactory.class); // note: as with base class, must NOT copy mapper reference return new MappingJsonFactory(null); } /* /********************************************************** /* Format detection functionality (since 1.8) /********************************************************** */ /** * Sub-classes need to override this method (as of 1.8) */ @Override public String getFormatName() { /* since non-JSON factories typically should not extend this class, * let's just always return JSON as name. */ return FORMAT_NAME_JSON; } /** * Sub-classes need to override this method (as of 1.8) */ @Override public MatchStrength hasFormat(InputAccessor acc) throws IOException { if (getClass() == MappingJsonFactory.class) { return hasJSONFormat(acc); } return null; } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std; import java.io.IOException; import java.lang.reflect.Type; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.JavaType; import com.fasterxml.jackson.databind.JsonMappingException; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.SerializerProvider; import com.fasterxml.jackson.databind.annotation.JacksonStdImpl; import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper; import com.fasterxml.jackson.databind.jsontype.TypeSerializer; import com.fasterxml.jackson.databind.util.TokenBuffer; /** * We also want to directly support serialization of {@link TokenBuffer}; * and since it is part of core package, it can not implement * {@link com.fasterxml.jackson.databind.JsonSerializable} * (which is only included in the mapper package) */ @JacksonStdImpl @SuppressWarnings("serial") public class TokenBufferSerializer extends StdSerializer<TokenBuffer> { public TokenBufferSerializer() { super(TokenBuffer.class); } @Override public void serialize(TokenBuffer value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { value.serialize(jgen); } /** * Implementing typed output for contents of a TokenBuffer is very tricky, * since we do not know for sure what its contents might look like (or, rather, * we do know when serializing, but not necessarily when deserializing!) * One possibility would be to check the current token, and use that to * determine if we would output JSON Array, Object or scalar value. * Jackson 1.5 did NOT include any type information; but this seems wrong, * and so 1.6 WILL include type information. *<p> * Note that we just claim it is scalar; this should work ok and is simpler * than doing introspection on both serialization and deserialization. */ @Override public final void serializeWithType(TokenBuffer value, JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer) throws IOException, JsonGenerationException { typeSer.writeTypePrefixForScalar

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> /********************************************************** */ @Override public int getParameterCount() { return _constructor.getParameterTypes().length; } @Override public Class<?> getRawParameterType(int index) { Class<?>[] types = _constructor.getParameterTypes(); return (index >= types.length) ? null : types[index]; } @Override public Type getGenericParameterType(int index) { Type[] types = _constructor.getGenericParameterTypes(); return (index >= types.length) ? null : types[index]; } @Override public final Object call() throws Exception { return _constructor.newInstance(); } @Override public final Object call(Object[] args) throws Exception { return _constructor.newInstance(args); } @Override public final Object call1(Object arg) throws Exception { return _constructor.newInstance(arg); } /* /********************************************************** /* AnnotatedMember impl /********************************************************** */ @Override public Class<?> getDeclaringClass() { return _constructor.getDeclaringClass(); } @Override public Member getMember() { return _constructor; } @Override public void setValue(Object pojo, Object value) throws UnsupportedOperationException { throw new UnsupportedOperationException("Cannot call setValue() on constructor of " +getDeclaringClass().getName()); } @Override public Object getValue(Object pojo) throws UnsupportedOperationException { throw new UnsupportedOperationException("Cannot call getValue() on constructor of " +getDeclaringClass().getName()); } /* /********************************************************** /* Extended API, specific annotations /********************************************************** */ @Override public String toString() { return "[constructor for "+getName()+", annotations: "+_annotations+"]"; } @Override public int hashCode() { return _constructor.getName().hashCode(); } @Override public boolean equals(Object o) { if (o == this) return true; if (o == null || o.getClass() != getClass()) return false; return ((AnnotatedConstructor) o)._constructor == _constructor; } /* /********************************************************** /* JDK serialization handling /********************************************************** */ Object writeReplace() { return new AnnotatedConstructor(new Serialization(_constructor)); } Object readResolve() { Class<?> clazz = _serialization.

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind; import java.io.*; import java.net.URL; import java.util.Iterator; import java.util.Locale; import java.util.Map; import java.util.TimeZone; import java.util.concurrent.ConcurrentHashMap; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.core.type.ResolvedType; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.cfg.ContextAttributes; import com.fasterxml.jackson.databind.deser.DataFormatReaders; import com.fasterxml.jackson.databind.deser.DefaultDeserializationContext; import com.fasterxml.jackson.databind.deser.DeserializationProblemHandler; import com.fasterxml.jackson.databind.node.JsonNodeFactory; import com.fasterxml.jackson.databind.node.NullNode; import com.fasterxml.jackson.databind.node.TreeTraversingParser; import com.fasterxml.jackson.databind.type.SimpleType; import com.fasterxml.jackson.databind.type.TypeFactory; import com.fasterxml.jackson.databind.util.RootNameLookup; /** * Builder object that can be used for per-serialization configuration of * deserialization parameters, such as root type to use or object * to update (instead of constructing new instance). *<p> * Uses "fluent" (or, kind of, builder) pattern so that instances are immutable * (and thus fully thread-safe with no external synchronization); * new instances are constructed for different configurations. * Instances are initially constructed by {@link ObjectMapper} and can be * reused, shared, cached; both because of thread-safety and because * instances are relatively light-weight. */ public class ObjectReader extends ObjectCodec implements Versioned, java.io.Serializable // since 2.1 { private static final long serialVersionUID = 1L; // since 2.5 private final static JavaType JSON_NODE_TYPE = SimpleType.constructUnsafe(JsonNode.class); /* /********************************************************** /* Immutable configuration from ObjectMapper /********************************************************** */ /** * General serialization configuration settings; while immutable, * can use copy-constructor to create modified instances as necessary.

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>Type(_config.constructType(valueType)); } /** * @deprecated since 2.5 Use {@link #forType(Class)} instead */ @Deprecated public ObjectReader withType(java.lang.reflect.Type valueType) { return forType(_config.getTypeFactory().constructType(valueType)); } /** * @deprecated since 2.5 Use {@link #forType(TypeReference)} instead */ @Deprecated public ObjectReader withType(TypeReference<?> valueTypeRef) { return forType(_config.getTypeFactory().constructType(valueTypeRef.getType())); } /** * Method for constructing a new instance with configuration that * updates passed Object (as root value), instead of constructing * a new value. *<p> * Note that the method does NOT change state of this reader, but * rather construct and returns a newly configured instance. */ public ObjectReader withValueToUpdate(Object value) { if (value == _valueToUpdate) return this; if (value == null) { throw new IllegalArgumentException("cat not update null value"); } JavaType t; /* no real benefit from pre-fetching, as updating readers are much * less likely to be reused, and value type may also be forced * with a later chained call... */ if (_valueType == null) { t = _config.constructType(value.getClass()); } else { t = _valueType; } return _new(this, _config, t, _rootDeserializer, value, _schema, _injectableValues, _dataFormatReaders); } /** * Method for constructing a new instance with configuration that * uses specified View for filtering. *<p> * Note that the method does NOT change state of this reader, but * rather construct and returns a newly configured instance. */ public ObjectReader withView(Class<?> activeView) { return _with(_config.withView(activeView)); } public ObjectReader with(Locale l) { return _with(_config.with(l)); } public ObjectReader with(TimeZone tz) { return _with(_config.with(tz)); } public ObjectReader withHandler(DeserializationProblemHandler h) { return _with(_config.withHandler

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> (may not be 'this') return match.getReader()._bindAndClose(p, _valueToUpdate); } @SuppressWarnings("resource") protected <T> MappingIterator<T> _detectBindAndReadValues(DataFormatReaders.Match match, boolean forceClosing) throws IOException, JsonProcessingException { if (!match.hasMatch()) { _reportUnkownFormat(_dataFormatReaders, match); } JsonParser p = match.createParserWithMatch(); // One more thing: we Own the input stream now; and while it's // not super clean way to do it, we must ensure closure so: if (forceClosing) { p.enable(JsonParser.Feature.AUTO_CLOSE_SOURCE); } // important: use matching ObjectReader (may not be 'this') return match.getReader()._bindAndReadValues(p, _valueToUpdate); } @SuppressWarnings("resource") protected JsonNode _detectBindAndCloseAsTree(InputStream in) throws IOException { DataFormatReaders.Match match = _dataFormatReaders.findFormat(in); if (!match.hasMatch()) { _reportUnkownFormat(_dataFormatReaders, match); } JsonParser p = match.createParserWithMatch(); p.enable(JsonParser.Feature.AUTO_CLOSE_SOURCE); return match.getReader()._bindAndCloseAsTree(p); } /** * Method called to indicate that format detection failed to detect format * of given input */ protected void _reportUnkownFormat(DataFormatReaders detector, DataFormatReaders.Match match) throws JsonProcessingException { throw new JsonParseException("Can not detect format from input, does not look like any of detectable formats " +detector.toString(), JsonLocation.NA); } /* /********************************************************** /* Internal methods, other /********************************************************** */ /** * @since 2.2 */ protected void _verifySchemaType(FormatSchema schema) { if (schema != null) { if (!_parserFactory.canUseSchema(schema)) { throw new IllegalArgumentException("Can not use FormatSchema of type "+schema.getClass().getName() +" for format "+_parserFactory.getFormatName()); } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> } /** * Internal helper method called to create an instance of {@link DeserializationContext} * for deserializing a single root value. * Can be overridden if a custom context is needed. */ protected DefaultDeserializationContext createDeserializationContext(JsonParser jp, DeserializationConfig cfg) { // 04-Jan-2010, tatu: we do actually need the provider too... (for polymorphic deser) return _context.createInstance(cfg, jp, _injectableValues); } protected void _reportUndetectableSource(Object src) throws JsonProcessingException { throw new JsonParseException("Can not use source of type " +src.getClass().getName()+" with format auto-detection: must be byte- not char-based", JsonLocation.NA); } protected InputStream _inputStream(URL src) throws IOException { return src.openStream(); } protected InputStream _inputStream(File f) throws IOException { return new FileInputStream(f); } }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> occurs if and only if the "value method" was annotated with * {@link com.fasterxml.jackson.databind.annotation.JsonSerialize#using}), otherwise * null */ @SuppressWarnings("unchecked") public JsonValueSerializer(Method valueMethod, JsonSerializer<?> ser) { super(valueMethod.getReturnType(), false); _accessorMethod = valueMethod; _valueSerializer = (JsonSerializer<Object>) ser; _property = null; _forceTypeInformation = true; // gets reconsidered when we are contextualized } @SuppressWarnings("unchecked") public JsonValueSerializer(JsonValueSerializer src, BeanProperty property, JsonSerializer<?> ser, boolean forceTypeInfo) { super(_notNullClass(src.handledType())); _accessorMethod = src._accessorMethod; _valueSerializer = (JsonSerializer<Object>) ser; _property = property; _forceTypeInformation = forceTypeInfo; } @SuppressWarnings("unchecked") private final static Class<Object> _notNullClass(Class<?> cls) { return (cls == null) ? Object.class : (Class<Object>) cls; } public JsonValueSerializer withResolved(BeanProperty property, JsonSerializer<?> ser, boolean forceTypeInfo) { if (_property == property && _valueSerializer == ser && forceTypeInfo == _forceTypeInformation) { return this; } return new JsonValueSerializer(this, property, ser, forceTypeInfo); } /* /********************************************************** /* Post-processing /********************************************************** */ /** * We can try to find the actual serializer for value, if we can * statically figure out what the result type must be. */ @Override public JsonSerializer<?> createContextual(SerializerProvider provider, BeanProperty property) throws JsonMappingException { JsonSerializer<?> ser = _valueSerializer; if (ser == null) { /* Can only assign serializer statically if the declared type is final: * if not, we don't really know the actual type until we get the instance. */ // 10-Mar-2010, tatu: Except if static typing is to be used if (provider.isEnabled(MapperFeature.USE_STATIC_TYPING) || Modifier.isFinal(_accessorMethod.getReturnType().getModifiers())) { JavaType

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> t = provider.constructType(_accessorMethod.getGenericReturnType()); // false -> no need to cache /* 10-Mar-2010, tatu: Ideally we would actually separate out type * serializer from value serializer; but, alas, there's no access * to serializer factory at this point... */ // 05-Sep-2013, tatu: I _think_ this can be considered a primary property... ser = provider.findPrimaryPropertySerializer(t, property); /* 09-Dec-2010, tatu: Turns out we must add special handling for * cases where "native" (aka "natural") type is being serialized, * using standard serializer */ boolean forceTypeInformation = isNaturalTypeWithStdHandling(t.getRawClass(), ser); return withResolved(property, ser, forceTypeInformation); } } else { // 05-Sep-2013, tatu: I _think_ this can be considered a primary property... ser = provider.handlePrimaryContextualization(ser, property); return withResolved(property, ser, _forceTypeInformation); } return this; } /* /********************************************************** /* Actual serialization /********************************************************** */ @Override public void serialize(Object bean, JsonGenerator jgen, SerializerProvider prov) throws IOException { try { Object value = _accessorMethod.invoke(bean); if (value == null) { prov.defaultSerializeNull(jgen); return; } JsonSerializer<Object> ser = _valueSerializer; if (ser == null) { Class<?> c = value.getClass(); /* 10-Mar-2010, tatu: Ideally we would actually separate out type * serializer from value serializer; but, alas, there's no access * to serializer factory at this point... */ // let's cache it, may be needed soon again ser = prov.findTypedValueSerializer(c, true, _property); } ser.serialize(value, jgen, prov); } catch (IOException ioe) { throw ioe; } catch (Exception e) { Throwable t = e; // Need to unwrap this specific

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> type, to see infinite recursion... while (t instanceof InvocationTargetException && t.getCause() != null) { t = t.getCause(); } // Errors shouldn't be wrapped (and often can't, as well) if (t instanceof Error) { throw (Error) t; } // let's try to indicate the path best we can... throw JsonMappingException.wrapWithPath(t, bean, _accessorMethod.getName() + "()"); } } @Override public void serializeWithType(Object bean, JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer0) throws IOException { // Regardless of other parts, first need to find value to serialize: Object value = null; try { value = _accessorMethod.invoke(bean); // and if we got null, can also just write it directly if (value == null) { provider.defaultSerializeNull(jgen); return; } JsonSerializer<Object> ser = _valueSerializer; if (ser == null) { // already got a serializer? fabulous, that be easy... // ser = provider.findTypedValueSerializer(value.getClass(), true, _property); ser = provider.findValueSerializer(value.getClass(), _property); } else { /* 09-Dec-2010, tatu: To work around natural type's refusal to add type info, we do * this (note: type is for the wrapper type, not enclosed value!) */ if (_forceTypeInformation) { typeSer0.writeTypePrefixForScalar(bean, jgen); ser.serialize(value, jgen, provider); typeSer0.writeTypeSuffixForScalar(bean, jgen); return; } } /* 13-Feb-2013, tatu: Turns out that work-around should NOT be required * at all; it would not lead to correct behavior (as per #167). */ // and then redirect type id lookups // TypeSerializer typeSer = new TypeSerializerWrapper(typeSer0, bean); ser.serializeWithType(value, jgen, provider, typeSer0); } catch (IOException ioe) { throw ioe; }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> catch (Exception e) { Throwable t = e; // Need to unwrap this specific type, to see infinite recursion... while (t instanceof InvocationTargetException && t.getCause() != null) { t = t.getCause(); } // Errors shouldn't be wrapped (and often can't, as well) if (t instanceof Error) { throw (Error) t; } // let's try to indicate the path best we can... throw JsonMappingException.wrapWithPath(t, bean, _accessorMethod.getName() + "()"); } } @SuppressWarnings("deprecation") @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) throws JsonMappingException { if (_valueSerializer instanceof SchemaAware) { return ((SchemaAware)_valueSerializer).getSchema(provider, null); } return com.fasterxml.jackson.databind.jsonschema.JsonSchema.getDefaultSchemaNode(); } @Override public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException { JsonSerializer<Object> ser = _valueSerializer; if (ser == null) { if (typeHint == null) { if (_property != null) { typeHint = _property.getType(); } if (typeHint == null) { typeHint = visitor.getProvider().constructType(_accessorMethod.getReturnType()); } } ser = visitor.getProvider().findTypedValueSerializer(typeHint, false, _property); if (ser == null) { visitor.expectAnyFormat(typeHint); return; } } ser.acceptJsonFormatVisitor(visitor, null); } protected boolean isNaturalTypeWithStdHandling(Class<?> rawType, JsonSerializer<?> ser) { // First: do we have a natural type being handled? if (rawType.isPrimitive()) { if (rawType != Integer.TYPE && rawType != Boolean.TYPE && rawType != Double.TYPE) { return false; } } else { if (rawType != String.class && rawType != Integer.class && rawType != Boolean.class && rawType != Double.class) { return false; } } return isDefaultSerializer(ser); } /* /**********************************************************

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser.std; import java.io.IOException; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.deser.BeanDeserializer; import com.fasterxml.jackson.databind.deser.SettableBeanProperty; import com.fasterxml.jackson.databind.util.NameTransformer; /** * Deserializer that builds on basic {@link BeanDeserializer} but * override some aspects like instance construction. */ public class ThrowableDeserializer extends BeanDeserializer { private static final long serialVersionUID = 1L; protected final static String PROP_NAME_MESSAGE = "message"; /* /************************************************************ /* Construction /************************************************************ */ public ThrowableDeserializer(BeanDeserializer baseDeserializer) { super(baseDeserializer); // need to disable this, since we do post-processing _vanillaProcessing = false; } /** * Alternative constructor used when creating "unwrapping" deserializers */ protected ThrowableDeserializer(BeanDeserializer src, NameTransformer unwrapper) { super(src, unwrapper); } @Override public JsonDeserializer<Object> unwrappingDeserializer(NameTransformer unwrapper) { if (getClass() != ThrowableDeserializer.class) { return this; } /* main thing really is to just enforce ignoring of unknown * properties; since there may be multiple unwrapped values * and properties for all may be interleaved... */ return new ThrowableDeserializer(this, unwrapper); } /* /************************************************************ /* Overridden methods /************************************************************ */ @Override public Object deserializeFromObject(JsonParser jp, DeserializationContext ctxt) throws IOException { // 30-Sep-2010, tatu: Need to allow use of @JsonCreator, so: if (_propertyBasedCreator != null) { // proper @JsonCreator return _deserializeUsingPropertyBased(jp, ctxt); } if (_delegateDeserializer != null) { return _valueInstantiator.createUsingDelegate(ctxt, _delegateDeserializer.deserialize(jp, ctxt)); } if (_beanType.isAbstract()) { // for good measure, check this too throw JsonMappingException.from(jp, "Can not instantiate abstract type "+_bean

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> public Iterator<JsonNode> elements() { return _children.values().iterator(); } @Override public JsonNode get(int index) { return null; } @Override public JsonNode get(String fieldName) { return _children.get(fieldName); } @Override public Iterator<String> fieldNames() { return _children.keySet().iterator(); } @Override public JsonNode path(int index) { return MissingNode.getInstance(); } @Override public JsonNode path(String fieldName) { JsonNode n = _children.get(fieldName); if (n != null) { return n; } return MissingNode.getInstance(); } /** * Method to use for accessing all fields (with both names * and values) of this JSON Object. */ @Override public Iterator<Map.Entry<String, JsonNode>> fields() { return _children.entrySet().iterator(); } @Override public ObjectNode with(String propertyName) { JsonNode n = _children.get(propertyName); if (n != null) { if (n instanceof ObjectNode) { return (ObjectNode) n; } throw new UnsupportedOperationException("Property '" + propertyName + "' has value that is not of type ObjectNode (but " + n .getClass().getName() + ")"); } ObjectNode result = objectNode(); _children.put(propertyName, result); return result; } @Override public ArrayNode withArray(String propertyName) { JsonNode n = _children.get(propertyName); if (n != null) { if (n instanceof ArrayNode) { return (ArrayNode) n; } throw new UnsupportedOperationException("Property '" + propertyName + "' has value that is not of type ArrayNode (but " + n .getClass().getName() + ")"); } ArrayNode result = arrayNode(); _children.put(propertyName, result); return result; } /* /********************************************************** /* Public API, finding value nodes /********************************************************** */ @Override public JsonNode findValue(String fieldName) { for (Map.Entry<String, JsonNode> entry : _children.entrySet()) { if (fieldName.equals(entry.getKey())) { return entry.getValue(); } JsonNode value = entry

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> null) { jgen.writeNull(); } else if (n instanceof String) { jgen.writeNumber((String) n); } else { throw new JsonGenerationException("Unrecognized value type for VALUE_NUMBER_FLOAT: "+n.getClass().getName()+", can not serialize"); } } break; case VALUE_TRUE: jgen.writeBoolean(true); break; case VALUE_FALSE: jgen.writeBoolean(false); break; case VALUE_NULL: jgen.writeNull(); break; case VALUE_EMBEDDED_OBJECT: jgen.writeObject(segment.get(ptr)); break; default: throw new RuntimeException("Internal error: should never end up through this code path"); } } } /** * Helper method used by standard deserializer. * * @since 2.3 */ public TokenBuffer deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException { if (jp.getCurrentTokenId() != JsonToken.FIELD_NAME.id()) { copyCurrentStructure(jp); return this; } /* 28-Oct-2014, tatu: As per #592, need to support a special case of starting from * FIELD_NAME, which is taken to mean that we are missing START_OBJECT, but need * to assume one did exist. */ JsonToken t; writeStartObject(); do { copyCurrentStructure(jp); } while ((t = jp.nextToken()) == JsonToken.FIELD_NAME); if (t != JsonToken.END_OBJECT) { throw ctxt.mappingException("Expected END_OBJECT after copying contents of a JsonParser into TokenBuffer, got "+t); } writeEndObject(); return this; } @Override @SuppressWarnings("resource") public String toString() { // Let's print up to 100 first tokens... final int MAX_COUNT = 100; StringBuilder sb = new StringBuilder(); sb.append("[TokenBuffer: "); /* sb.append("NativeTypeIds=").append(_hasNativeTypeIds).append(","); sb.append("NativeObjectIds=").append(_hasNativeObjectIds).append(","); */ JsonParser

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS>(JsonToken.VALUE_NUMBER_FLOAT, encodedValue); } @Override public void writeBoolean(boolean state) throws IOException,JsonGenerationException { _append(state ? JsonToken.VALUE_TRUE : JsonToken.VALUE_FALSE); } @Override public void writeNull() throws IOException, JsonGenerationException { _append(JsonToken.VALUE_NULL); } /* /*********************************************************** /* JsonGenerator implementation: write methods for POJOs/trees /*********************************************************** */ @Override public void writeObject(Object value) throws IOException { if (value == null) { writeNull(); return; } Class<?> raw = value.getClass(); if (raw == byte[].class) { _append(JsonToken.VALUE_EMBEDDED_OBJECT, value); return; } else if (_objectCodec == null) { /* 28-May-2014, tatu: Tricky choice here; if no codec, should we * err out, or just embed? For now, do latter. */ // throw new JsonMappingException("No ObjectCodec configured for TokenBuffer, writeObject() called"); _append(JsonToken.VALUE_EMBEDDED_OBJECT, value); } else { _objectCodec.writeValue(this, value); } } @Override public void writeTree(TreeNode node) throws IOException { if (node == null) { writeNull(); return; } if (_objectCodec == null) { // as with 'writeObject()', is codec optional? _append(JsonToken.VALUE_EMBEDDED_OBJECT, node); } else { _objectCodec.writeTree(this, node); } } /* /*********************************************************** /* JsonGenerator implementation; binary /*********************************************************** */ @Override public void writeBinary(Base64Variant b64variant, byte[] data, int offset, int len) throws IOException, JsonGenerationException { /* 31-Dec-2009, tatu: can do this using multiple alternatives; but for * now, let's try to limit number of conversions. * The only (?) tricky thing is that of whether to preserve variant, * seems pointless, so let

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> IOException, JsonParseException { return getNumberValue().doubleValue(); } @Override public float getFloatValue() throws IOException, JsonParseException { return getNumberValue().floatValue(); } @Override public int getIntValue() throws IOException, JsonParseException { // optimize common case: if (_currToken == JsonToken.VALUE_NUMBER_INT) { return ((Number) _currentObject()).intValue(); } return getNumberValue().intValue(); } @Override public long getLongValue() throws IOException, JsonParseException { return getNumberValue().longValue(); } @Override public NumberType getNumberType() throws IOException, JsonParseException { Number n = getNumberValue(); if (n instanceof Integer) return NumberType.INT; if (n instanceof Long) return NumberType.LONG; if (n instanceof Double) return NumberType.DOUBLE; if (n instanceof BigDecimal) return NumberType.BIG_DECIMAL; if (n instanceof BigInteger) return NumberType.BIG_INTEGER; if (n instanceof Float) return NumberType.FLOAT; if (n instanceof Short) return NumberType.INT; // should be SHORT return null; } @Override public final Number getNumberValue() throws IOException, JsonParseException { _checkIsNumber(); Object value = _currentObject(); if (value instanceof Number) { return (Number) value; } // Difficult to really support numbers-as-Strings; but let's try. // NOTE: no access to DeserializationConfig, unfortunately, so can not // try to determine Double/BigDecimal preference... if (value instanceof String) { String str = (String) value; if (str.indexOf('.') >= 0) { return Double.parseDouble(str); } return Long.parseLong(str); } if (value == null) { return null; } throw new IllegalStateException("Internal error: entry should be a Number, but is of type " +value.getClass().getName()); } /* /********************************************************** /* Public API, access to token information, other /********************************************************** */ @Override public Object getEmbeddedObject() { if (_currToken == JsonToken.VALUE_EMBEDDED_OBJECT) { return _currentObject(); }

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> if (ser == null) { // 30-Sep-2012, tatu: One more thing -- if explicit content type is annotated, // we can consider it a static case as well. if (_elementType != null) { // 20-Aug-2013, tatu: Need to avoid trying to access serializer for java.lang.Object tho if ((_staticTyping && _elementType.getRawClass() != Object.class) || hasContentTypeAnnotation(provider, property)) { ser = provider.findValueSerializer(_elementType, property); } } } else { ser = provider.handleSecondaryContextualization(ser, property); } if ((ser != _elementSerializer) || (property != _property) || _valueTypeSerializer != typeSer) { return withResolved(property, typeSer, ser); } return this; } /* /********************************************************** /* Accessors /********************************************************** */ @Override public JavaType getContentType() { return _elementType; } @Override public JsonSerializer<?> getContentSerializer() { return _elementSerializer; } /* /********************************************************** /* Serialization /********************************************************** */ // NOTE: as of 2.5, sub-classes SHOULD override (in 2.4 and before, was final), // at least if they can provide access to actual size of value and use `writeStartArray()` // variant that passes size of array to output, which is helpful with some data formats @Override public void serialize(T value, JsonGenerator gen, SerializerProvider provider) throws IOException { if (provider.isEnabled(SerializationFeature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED) && hasSingleElement(value)) { serializeContents(value, gen, provider); return; } gen.writeStartArray(); // [databind#631]: Assign current value, to be accessible by custom serializers gen.setCurrentValue(value); serializeContents(value, gen, provider); gen.writeEndArray(); } @Override public void serializeWithType(T value, JsonGenerator gen, SerializerProvider provider, TypeSerializer typeSer) throws IOException { // note: let's NOT consider [JACKSON-805] here; gets too complicated,

JacksonDatabind, 15

<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB> @Override public boolean isCollectionLikeType() { return false; } /** * @return True if type is either true {@link java.util.Map} type, * or something similar (meaning it has at least two type parameter; * first one describing key type, second value type) */ @Override public boolean isMapLikeType() { return false; } /** * Convenience method, short-hand for *<code> * getRawClass() == Object.class *</code> * and used to figure if we basically have "untyped" type object. * * @since 2.5 */ <CHANGES> <CHANGEE> /** * Accessor for checking whether handlers for dealing with values of * this type should use static typing (as opposed to dynamic typing). * Note that while value of 'true' does mean that static typing is to * be used, value of 'false' may still be overridden by other settings. * * @since 2.2 */ public final boolean useStaticType() { return _asStatic; } /* /********************************************************** /* Public API, type parameter access; pass-through <FILEE> <FILEB> staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); } } // Slight detour: do we have a Converter to consider? Converter<Object,Object> conv = beanDesc.findSerializationConverter(); if (conv == null) { // no, simple return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); // One more twist, as per [Issue#288]; probably need to get new BeanDesc if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); // [#359]: explicitly check (again) for @JsonSerializer... ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } // [databind#731]: Should skip if nominally java.lang.Object <CHANGES> if (ser == null) { <CHANGEE> ser = _createSerializer2(<SCANS> and probably just won't work typeSer.writeTypePrefixForArray(value, gen); // [databind#631]: Assign current value, to be accessible by custom serializers gen.setCurrentValue(value); serializeContents(value, gen, provider); typeSer.writeTypeSuffixForArray(value, gen); } protected abstract void serializeContents(T value, JsonGenerator gen, SerializerProvider provider) throws IOException; @SuppressWarnings("deprecation") @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) throws JsonMappingException { ObjectNode o = createSchemaNode("array", true); JavaType contentType = _elementType; if (contentType != null) { JsonNode schemaNode = null; // 15-Oct-2010, tatu: We can't serialize plain Object.class; but what should it produce here? Untyped? if (contentType.getRawClass() != Object.class) { JsonSerializer<Object> ser = provider.findValueSerializer(contentType, _property); if (ser instanceof SchemaAware) { schemaNode = ((SchemaAware) ser).getSchema(provider, null); } } if (schemaNode == null) { schemaNode = com.fasterxml.jackson.databind.jsonschema.JsonSchema.getDefaultSchemaNode(); } o.put("items", schemaNode); } return o; } @Override public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException { JsonArrayFormatVisitor arrayVisitor = (visitor == null) ? null : visitor.expectArrayFormat(typeHint); if (arrayVisitor != null) { /* 01-Sep-2014, tatu: Earlier was trying to make use of 'typeHint' for some * reason, causing NPE (as per https://github.com/FasterXML/jackson-module-jsonSchema/issues/34) * if coupled with `@JsonValue`. But I can't see much benefit of trying to rely * on TypeHint here so code is simplified like so: */ JsonSerializer<?> valueSer = _elementSerializer; if (valueSer == null) { valueSer = visitor.getProvider().findValueSerializer(_elementType, _property);